Research with receipts: what legal research looks like when every claim has to prove itself

When you hand a research question to a good associate, they don't run one search and paste you the results. They think about the question first. They decide what they need: the file, the correspondence, the deposition transcripts, the caselaw, maybe the docket. They pull sources, judge whether they have enough, and go back for more where they don't. Then they write you a memo where every assertion has support — and where the honest answer to a hole in the research is "I couldn't find authority for this," not a confident sentence papering over the gap.

Most legal research AI fails that standard twice. Chatbots guess from the open web — which is exactly how fabricated citations end up in filings. Research platforms know the law but not your cases, so the half of the question that lives in your own record never enters the analysis. Lex Research was built to meet the associate standard on both halves, and then to do something no associate can: enforce, mechanically, that every claim in the answer carries its evidence.

It plans before it retrieves

Lex Research is agentic — multi-step, not one-shot retrieval. It plans the question, decides which sources it needs, queries, evaluates whether it has enough, and refines where it doesn't. And crucially, its sources include your firm's own record: matters, documents, email, transcripts, deadlines, and billing, alongside the caselaw, primary legal sources, and the open web.

That matters because real research questions are almost never purely legal. Suppose you're working Hale v. Northstar Logistics and you ask whether the maintenance records opposing counsel produced last month undercut their expert's timeline. Answering that requires the produced documents, the deposition transcript, and the law on the evidentiary question — three different kinds of source, two of which live only in your own file. A research tool that can't read your record can't answer the question you actually asked. Lex plans across all of it and returns one cited memo.

The citation ledger lives inside your deployment

Caselaw is where research AI has burned the profession, so it's worth being precise about how citations work here. A national citation authority ledger — built from the Free Law Project's CourtListener corpus, covering essentially every published US caselaw citation — lives inside your firm's deployment. When Lex cites a case, the citation verifies locally, against that ledger, with zero data egress. Your research questions don't leave your infrastructure to check whether a case exists.

Pause on "zero data egress," because it's easy to read past. Legal research is not a neutral activity — the questions a firm asks reveal what it's worried about, which theories it's testing, and where it thinks a case is weak. A research platform that sees every query a firm runs sees the firm's thinking. Verifying citations against a ledger that lives inside your own deployment means that layer of the work never becomes someone else's data.

For fresh or contested cites, verification escalates to a live check against CourtListener. And when you want the case itself rather than confirmation it exists, Lex pulls the actual opinion text on demand. Statutes, regulations, and court rules answer from governmental and primary legal sources — and deadline math comes from Cascade with the rule authority attached to every date, not from a model's recollection of how service extensions work.

The open web is available too, but on a leash: searches are biased toward authoritative legal sources, and everything retrieved is saved to the matter as a sourced artifact. Found law becomes evidence on the record, not a browser tab that vanished before anyone could check it.

The evidence gate: a claim that can't be grounded is blocked

Here is the part that separates this from every tool that merely adds footnotes. Every claim in a Lex Research answer carries typed evidence — a document span, an email span, a verified citation, a rule authority, a ledger entry. Before the answer renders, each claim is checked against its evidence. A claim with no supporting span is blocked. Not softened, not hedged, not padded over with plausible prose — blocked, and shown to you as blocked.

Other research tools cite. EdgeLex enforces — and an ungrounded claim is shown as blocked, never padded over.

Think about what a visible blocked claim actually tells you. It tells you where the research is thin. It tells you what a competent associate would have flagged in a cover email: "I couldn't support this point." A generative model with no evidence gate gives you the opposite — its weakest claims arrive dressed exactly like its strongest ones, and finding the difference is your job, on your time, under your malpractice policy. The evidence gate moves that burden back onto the machine, where it belongs.

Cite-checked before it reaches a filing

Research feeding a brief gets a second, independent layer: EdgeCite. Before any AI judgment runs, every citation is validated deterministically against the authority ledger — a lookup, not an opinion. The ordering is the point. The provable check happens first, so the baseline is fact, and AI resolution operates only on top of it. From there:

• Known citations verify against the ledger by deterministic lookup — no model in the loop.
• Unknowns escalate to live verification.
• Judgment calls route to a human review queue rather than being silently resolved.
• A citation graph tracks how your documents rely on which cases — holding, dicta, or criticism — so you know not just that a cite is real, but what kind of weight it's carrying.

Fabricated citations are the failure mode this architecture exists to kill. The check isn't a disclaimer asking you to verify the output; it's a deterministic gate the output has to pass.

Research becomes work product, not a chat transcript

An associate's research memo doesn't live in their head; it goes in the file, and it generates next steps. Lex Research works the same way. The memo saves to the matter in the DMS. Proposed tasks land in Triage, where nothing becomes a commitment without an owner and a date. Results deliver to EdgeMessage. Every write is approval-gated — the research becomes part of the matter because you accepted it, not because a chatbot decided it should.

This closes the quiet failure of chat-based research: good analysis that evaporates. Two months later, when the same question comes up at the summary judgment stage, the memo is in the DMS next to the pleadings — with its evidence trail intact — instead of buried in someone's chat history.

Standing research: it runs when the event fires

Pair Lex Research with Lex Delegations and it stops waiting to be asked. "Whenever opposing counsel files anything, verify every authority they cite and brief me on the ones that matter" is one sentence, said once. From then on, the filing arrives, the delegation wakes, every cited authority runs through verification, and the briefing lands as a reviewed deliverable — while you were doing something else. Research on the events of the case, not on your memory to request it.

Your model does the reasoning

One more piece completes the picture: the model doing the research is the model your firm chose. Lex Research runs on frontier models, local open-source models on the firm's own hardware, or the firm's own fine-tuned model — under the same governance either way. And the platform's routing layer keeps underpowered models away from work they can't carry.

The reason this belongs in an article about research quality is that the safeguards don't depend on the model behaving. The evidence gate checks claims regardless of which model wrote them; the citation ledger validates regardless of which model cited. That's a deliberate inversion of how most AI products are built, where quality is whatever the model happens to produce that day. Here the architecture sets the floor, and the model choice determines how far above it the work rises.

The standard to hold any research AI to

Strip away the product language and the questions are simple. Does it plan, or does it run one search? Can it read your own record, or only the public law? Where do citations verify — inside your deployment, or on a vendor's servers your client data has to visit? When a claim can't be supported, does the tool tell you, or does it write around the hole? And when the research is done, is it in the file with its evidence, or in a transcript nobody will find again?

You already hold people to this standard. An associate who invented a citation, hid the weak points, and kept their research out of the file wouldn't last the month. The only reason to hold software to less is that, until recently, software couldn't do better. It can now — and the whole trail, from question to claim to authority, is auditable.