Harvey open-sources a synthetic law firm with 108M tokens and 9,288 documents
- Harvey built a fake law firm from scratch, put all files for 266 matters on GitHub, and let AI agents dig for answers.
- Two frontier models ace about 70–80% of individual checkpoints, but when asked to get every single one, they drop to 24.4% and 36.0%.
- Questions with more than 16 checkpoints see the full-pass rate fall to exactly zero — while the models don't actually get dumber on hard questions.
The firm is fake. The scale is real.
Legal AI company Harvey has open-sourced an entire law firm's archive: 266 matters, 9,288 Word documents, and 108 million tokens are all on GitHub, paired with 250 questions for AI to answer. The archive, the questions, the scoring rubric, and the benchmark results are all publicly available.
Why build this dataset? In a real law firm, finding things is a pain: documents pile up endlessly, and much of the key information has no fixed keyword you can search for. Previous legal benchmarks were all "here's a contract, answer a question" — the material was handed to you, so they never tested this skill. This dataset is a new extension of LAB, Harvey's legal agent benchmark.
First, you need to understand how a law firm organizes its work, because that's exactly how this dataset is built. Everything runs on two relationships: the client (who you're working for) and the matter (the specific piece of work for that client). Here, 46 clients span 15 practice areas. One client can have many matters, and one matter might pull in lawyers from several practice groups.
The 46 clients include both companies and individuals, and they were deliberately made as diverse as possible: what a PE fund needs is completely different from what an industrial manufacturer needs. The more varied the clients, the more practice areas you can cover. Of the 266 matters, some are closed and some are still active.
It's one specific piece of work a firm does for a client — everything from the engagement letter to the closing memo lives under that matter. Think of it like a "project" folder in project management software, except in a law firm it's also the billing unit and a drawer in the filing cabinet. The folder number is "client number, hyphen, sequence number": 1003-00001 is the first matter for client 1003.
A matter's documents cover its full lifecycle: how the work was won, how it was staffed, the major decisions along the way, and the final outcome. Files are organized into folders per matter, but the organization is deliberately inconsistent — each matter's folders look different, depending on the matter type, the partner's habits, and how the work actually played out. Real firms are just this messy; nobody standardized how files should be arranged.
Every document grows from a 1,000-token script
Writing this many files by hand was never an option. Harvey's approach: for each matter, first write a "script" of roughly 1,000 tokens that covers two things — which client this is for, and roughly what the project looks like. Then the script is stuffed with concrete facts: some are fine-grained, like "the escrow amount in this agreement is 10%" or "the non-compete is two years"; others are structural, like "this litigation was dismissed" or "this one settled."
The clever part is the last step: to define the ground truth, you only need to read that 1,000-token script — you don't have to review the millions of rendered documents. Otherwise, who's going to audit 108 million tokens?
Those planted fact points have a second identity: they are the scoring answer key. But the AI never sees them. It only gets the stack of Word documents and has to use search and reasoning to dig up scattered clues and piece together an answer.
How real does the synthetic data get? I downloaded one to check: second-request-strategy-memo.docx, 66KB, 344 paragraphs, a fully fleshed-out lawyer's memo. The header says "Confidential · Attorney Work Product." It cites 15 U.S.C. § 18a, notes the 2024 filing threshold of $119.5 million and the $160,000 filing fee, and walks through a timeline — purchase agreement signed June 4, filed June 18, regulator requested materials July 8, formal second request issued July 16 — with zero inconsistencies across names, companies, and dates.
The initial 30-day statutory waiting period under the HSR Act was set to expire on July 18, 2024. However, on July 8, 2024, the FTC's Bureau of Competition, Mergers IV Division issued a voluntary access letter … We produced 23 supplemental documents on July 10, 2024, in response to that voluntary access letter.
All 250 questions sound like a partner's offhand remark
So we have the archive. What do the questions look like? The 250 questions simulate real requests a law firm might make to its own document management system. They're plain-spoken, single-sentence asks — the kind of thing a partner blurts out while walking past your desk in the morning.
I pulled the actual task files from the repo. Question 1 reads: "I'm reviewing the transactions that triggered regulatory scrutiny in my antitrust group. Pull all the matters that received an HSR Second Request, along with the related correspondence."
Above a certain size, US mergers must be reported to regulators. If the agency thinks competition might be harmed, it sends a formal demand for more information, and the deal has to pause until reviewed. Like a visa application getting a "Request for Evidence" — it's not a denial, but your timeline suddenly has no end date.
The ground truth for this question has 11 items:
Notice that last rule: even the test authors had to write a paragraph explaining which matters count and which don't.
But there's no index. The AI has to read every file.
One more thing to be clear about: for every single question, the AI faces the entire file system. All 266 matters are spread out in front of it, with no one telling it where to look.
The agent has six tools: run command, read file, write file, edit file, find by filename, and search by content. It does get grep — the problem is having a keyword to search for.
I checked the file system myself: under dms/matters/ there are just 266 numeric directories. No index. No client list. No practice-area mapping. No metadata file of any kind. To find out what client 1003 is, which practice area it belongs to, or how the matter resolved, you have to open the Word documents and read them one by one.
For a question like "which matters in our antitrust group received a second request," searching for "second request" returns a huge pile, but "does this matter actually belong to the antitrust group" is a fact no field in the archive will tell you. You have to read the documents to figure it out. That note from the previous section — "these three other matters are neither here nor there" — exists precisely because this boundary is hard even for a human to articulate.
And the rule is: miss one checkpoint, get zero
Each question's ground truth is split into individual pass/fail checkpoints, judged one by one by an AI grader (claude-sonnet-4-6, temperature set to 0, looking for semantic equivalence, not keyword matches). All checkpoints must pass to earn 1 point—miss just one and you get 0. There's no partial credit. Harvey calls this all-pass scoring.
Why be so strict? The reasoning goes:
In real legal delivery, averages are misleading. A due diligence memo that catches 95% of the issues but misses one material one isn't "95% useful." It's wrong. Harvey LAB eval methodology doc
That missed issue could change the deal price, force a redo before closing, or blow up after signing.
It's a pre-flight checklist. If you check 99 items and skip one, the plane isn't "99% airworthy." It doesn't fly.
Neither frontier model passed
Rules out of the way, here are the scores. Harvey ran two models through LAB's standard execution framework:
| Metric | opus-4.8-high | gpt-5.6-sol-high |
|---|---|---|
| Individual checkpoint pass rate | 71.7% | 79.1% |
| Full-pass rate | 24.4% | 36.0% |
| Median time per question | 475s | 406s |
| Median cost per question | $1.26 | $1.66 |
An individual checkpoint pass rate of 70–80% sounds decent. But when the bar shifts to "answer the whole question without missing a single point," it collapses to 20–30%. 475 seconds is about eight minutes—per question. At median cost, running all 250 questions once comes to roughly $300. The two models mostly overlap on the easy wins, and each manages to crack a few the other can't.
Checkpoints stay steady. Full-pass collapses.
Looking at the overall score isn't enough. Split the 250 questions into four tiers by "how many checkpoints the ground truth has," and the two lines head in opposite directions.
The other model, gpt-5.6-sol, holds up a bit longer—full-pass rate goes from roughly 51% to 27% to around 20%—but in the "26+" tier, it also hits exactly 0%.
Intuitively, the math explains it. A 71.7% per-checkpoint pass rate, applied to 26 checkpoints, is 0.717 raised to the 26th power — roughly 0.02%. The models aren't getting dumber on hard questions; what punishes them is the all-or-nothing requirement. The longer the checklist, the faster your odds of a perfect run collapse. (This arithmetic is just to build intuition; checkpoints aren't fully independent — finding one matter often satisfies several at once, so you can't take these probabilities literally.)
The real problem: the AI doesn't know when it's done searching
So where exactly does it go wrong? Harvey dug into the agents' full execution traces, and the conclusion runs counter to intuition.
The models' reasoning about what they found is mostly correct. Where they fail is in finding every relevant piece of information. And it's not a search-strategy problem — they reliably locate the core facts and satisfy a subset of the rubric. What's missing is the judgment of "should I keep looking?"
This is especially deadly for "give me the full list" style questions — which is exactly where the cliff in the chart above is steepest.
Harvey's root-cause conclusion: the agent never builds an internal model of "what's in this archive." Without that, it has no basis for judging whether its search is thorough enough.
It's like an assistant on day one of the job. Hand it any document and it reads it perfectly, analyzes it correctly. But it has no idea how many files exist in the archive, so it can never know whether it's finished. Ask "did you find everything?" and it can only say, "Here's everything I found."
Harvey's bet: read the archive into an index first
Legal work is fundamentally about figuring out how the current problem relates to what's been done before: which precedent applies to this client, what's market practice. But today's agents re-derive all that knowledge from scratch for every single task. At enterprise scale, that approach is both too expensive and too weak.
That's the direction they're betting on: have the agent first read the archive into its own index, then answer questions. Because the environment is persistent — the same archive gets asked 250 times — the one-time cost of "getting to know" the corpus pays off. Expect more releases in this vein; their partner Engram literally builds the memory layer for AI, having emerged from stealth this June with $98M in funding.
Harvey is also explicit about the dataset's limits: it currently covers only part of law firm work, and 250 questions are just a subset of what lawyers might ask. More will be added. Also, looking at the run logs, both cost and time scale up with corpus size — and a real enterprise archive can be orders of magnitude larger than this fake firm.
Two frontier AIs dig through an entire fake law firm — and still can't return a single answer without missing something
Harvey built a 9,288-document fake law firm to test AI. This page shows where two top models fall short.
↓ One page, one animated chart
Harvey created a law firm that doesn't exist, put its entire archive on GitHub, and added 250 questions for AI to answer.
One client can have many matters; one matter often pulls in multiple practice groups. The whole structure mirrors the real-world mess of law firms — folders are deliberately not standardized.
The AI gets search tools, but there's nothing to search *for*. The repo contains 266 numeric folders, no index, no client list, no explanations. To learn whose matter it is or whether it belongs to a certain group, you have to open documents and read.
Even the test authors had to add a note in the answer key explaining which matters count and which don't.
The answer key is split into individual checkpoints, judged by an AI grader one by one: all must pass for the question to count. Miss one, and it's a zero — no partial credit.
Harvey ran two frontier models: opus-4.8-high and gpt-5.6-sol-high. On individual checkpoints, both land in the 70–80% range. Require them to get *everything*, and they fall to 20–30%.
Scores come from Harvey's self-run LAB eval; no third-party replication yet. A single question takes ~400+ seconds and $1–2 at the median.
Harvey reviewed the agent traces: the models' reasoning about what they found is mostly right. What fails is completeness. At the core, they have no model of "how much is even in this archive," so they can't judge whether they've searched enough.
The fix: have the AI spend the effort once to read the archive into an index, summary, and memory — then answer questions. Same 250 questions hit the same files, so the upfront cost amortizes.
- × Client list
- × Practice area map
- × Any explanation
Members can copy or download the full Markdown, and let their AI subscribe and ask.
Found this useful? Leave your email — every new explainer, the moment it's out. Unsubscribe anytime.
