A retrieval system designed around Trust.

Three signals, fused. Not keyword search alone.

Stage-1 retrieval, the step that decides which matters to look at, blends three signals: semantic similarity over matter summaries, full-text search over the ledger, and a one-step walk over the matter cross-reference graph.

The three signals are fused with reciprocal rank fusion (RRF) at k = 60. Rank-1 order is RRF-driven; cosine remains attached to every candidate for transparency and downstream routing.

This matters because cosine alone gets the wrong lead matter on a non-trivial fraction of real queries. RRF lets a matter that is moderately similar on text but strongly connected to the right cluster, or one that the ledger surfaces on a partner name or matter type, beat a noisier cosine winner.

rrf_score(matter) = Σ  1 / (k + rank_in_signal_i)
                    i ∈ {cosine, fts, graph}

k = 60

The trade-off is deliberate: RRF accepts that no single signal is authoritative. The system reports all three, ranked and fused, so the shortlist is defensible to the lawyer reading it, not just to the model.

Matters first. Paragraphs second. With a doc-type diversity floor.

Stage 2 is per-matter. For each shortlisted matter, the system retrieves up to M answer paragraphs (default 3) and K reflection paragraphs (default 2) from the matter's documents.

Answer paragraphs exclude reflection document types (post-matter reviews, research memos) and are subject to a doc-type diversity penalty. The selection avoids stacking three paragraphs from the same memo when other documents in the matter could speak to the question.

Reflection paragraphs are pulled separately and force-included regardless of cosine score, because reflection content (limitation language, hindsight notes, “first-of-its-kind” flags) is what feeds the gap detection layer downstream.

This is why the home-page demo's bench picture is honest about how many matters were touched: the system structurally cannot collapse five matters into one paragraph from one document. Diversity is enforced at retrieval, not begged for at synthesis.

What retrieval actually returned, surfaced before the model writes.

The bench picture is six deterministic fields plus three transparency stats. Built from the matters table and the stage-1 shortlist directly. No LLM involvement.

Six fields: matter count, practice distribution, lead-partner concentration, temporal spread, office distribution, deal value range where known.

Three transparency stats: stage-1 cosine span, cosine gap between rank-1 and rank-N, paragraph depth across the bundle. These let the reader judge whether the shortlist is tight or diffuse without asking the model to self-assess.

{
  "matter_count": 3,
  "practices": ["Corporate / M&A"],
  "lead_partners": {
    "David Okafor": 2,
    "James Whitfield": 1
  },
  "temporal_spread": "2021 – 2024",
  "offices": ["London"],
  "deal_value_range_gbp_m": [180, 285],
  "transparency": {
    "cosine_span_top5": 0.067,
    "cosine_gap_rank1_rank3": 0.041,
    "paragraph_depth": 11
  }
}

The bench picture is non-negotiable. Every response carries it. If retrieval returned only one matter, the bench says so plainly, including the degraded-copy convention (“Firm's only matter on this fact pattern”) that makes thin retrieval visible rather than hidden.

The system doesn't conflate “we don't know” with “we don't know yet.”

The gaps and limits panel runs every response. It's never omitted. The content comes from four distinct channels, surfaced separately so the reader can tell which kind of gap they're looking at.

T1 through T3 are built at retrieval time, deterministically, from the data. T4 is the only channel that the language model contributes to, and the model can only write into T4 if it explicitly flagged a question facet as unsupported in its own structured output.

This is the trust architecture's load-bearing decision. The gap panel cannot say something the retrieval layer hasn't already established. The model cannot hallucinate a gap any more than it can hallucinate an answer.

Five response shapes. One pipeline.

Firm Memory routes queries to one of five response shapes before synthesis runs. The router reads stage-1 output (RRF rank, cosine, paragraph counts, gap-matter membership) and picks the shape that matches the epistemic reality of what was found.

The shapes exist because the same prompt can't produce the right answer for both “have we advised on this exact fact pattern” and “have we ever done anything like this.” Stretching one template to fit both is the failure mode behind every confidently wrong RAG demo.

Each shape has its own prompt template and its own claim cap. Hero shape permits breadth across matters with confident multi-source claims. Thin shape says less and signals the narrow base. Known-empty shapes refuse to fabricate substance. Refuse shape stops before synthesis runs at all.

The router is deterministic. The same query in the same corpus state produces the same shape.

Every sentence cites a paragraph. The model cannot answer ungrounded.

Synthesis output is a JSON object with two fields: a claims array where each item is one sentence with one or more paragraph citations, and an unsupported_aspects array (which feeds gap channel T4).

{
  "claims": [
    {
      "text": "Three matters establish the relevant precedent.",
      "citations": [
        "HC-2021-MA-0089:matter_opening_memo:1",
        "HC-2023-MA-0142:matter_opening_memo:1",
        "HC-2024-MA-0167:comprehensive_deal_summary:3"
      ]
    }
  ],
  "unsupported_aspects": [
    "post-completion enforcement outcomes for the three matters"
  ]
}

Every citation key (matter_id:doc_type:paragraph_idx) is validated against the retrieval set before the response is shown to the user. A hallucinated citation, a key that doesn't exist in the actual retrieved paragraphs, fails validation and triggers one retry with a stricter prompt reminder.

If the retry also fails validation, the system surfaces degraded output rather than confidently wrong output. Degraded output is rare in the canonical eval (0 of 30 queries on the last full run).

The one-sentence-per-claim constraint is enforced both at the prompt level and at the validation layer. It's the smallest unit of citation we found that holds: a sentence is short enough to be grounded specifically, long enough to carry meaning on its own.

The system refuses what a knowledge tool shouldn't do.

Three categories of question are blocked before synthesis runs:

The gate is deterministic, not LLM-based. Patterns are explicit and testable. A query that triggers the gate gets a single sentence back and nothing more.

This is the cheapest trust signal in the system and the most often missed by competing RAG demos. A research tool that confidently drafts a client letter is a research tool with no boundary. The boundary is the product.

30 queries. Six axes. A regression-grade test the product is built around.

Firm Memory's behaviour is locked by an evaluation kit that runs against the corpus before every release. 30 queries spanning hero, mid, gap, OOS, and adversarial categories. Each query is scored on six binary axes:

The kit also runs architectural invariants, checks that hold across the whole run, not per-query:

We publish the eval state because trust architecture is not a slide. It's a number. 29 of 30 on a 30-query adversarial kit, with the one fail documented, is the version of credibility we'd want to see from a vendor ourselves.