Version 110 in Four Days

The brief that went out was version 110.

Four days earlier it had been version 1. Not because an AI wrote a hundred and ten drafts while I watched — it didn't — but because the loop between "here is a draft" and "here is precisely what is wrong with it" collapsed from most of a day to a few minutes.

When that loop is short enough, you stop treating a draft as something you commit to and start treating it as something you interrogate. That is the whole story. Everything below is the machinery that makes the loop short.

The loop

The cycle is deliberately boring:

1. Draft — version n exists.
2. Report — ask for a structured critique against the record and the law.
3. Revise — fix what the report found. Version n+1.
4. Repeat.

A report is not "make this better." It's a specific interrogation, run against two different sources of truth:

• Every factual assertion in section III — find its support in the record, give me the page, and flag anything you cannot locate.
• Every case cited — confirm it exists, confirm the proposition, flag anything that has been questioned.
• Compare this argument to how the other side framed it in their response, and tell me what I am not answering.

Done by hand, that's an afternoon per pass. You get three or four passes before filing, and you spend them on the arguments you already suspect are weak — which means the ones you don't suspect never get examined.

At a few minutes per pass, you run it after every meaningful change. Iteration stops being rationed.

Why the count matters more than the draft

There's a tempting misreading here: that a hundred and ten versions means the AI wrote a hundred and ten drafts, each slightly better.

It doesn't. Most of those versions changed one paragraph. Some changed one sentence. A few were reverts, because the report showed a "fix" had broken something upstream.

What the number actually measures is how many times the brief was checked against reality. A hundred and ten passes over four days is a different artefact from four passes over four weeks, and it's different in a way that shows up in the specific places lawyers get caught: the citation that doesn't quite say what you needed it to say, the fact that migrated from "the record shows" to "everyone knows," the argument the other side made that you answered in your head but not on the page.

The desk

All of this happens in Claude Desktop, with two MCP servers connected.

MCP — Model Context Protocol — is a standard way to give an AI assistant tools. Rather than pasting documents into a chat, you connect it to systems it can query directly. Two matter here:

The part worth understanding

Neither of these tools knows the other exists.

Sound Suite has no idea what CourtListener is. CourtListener has never heard of your case file. There is no integration between them, no connector, no shared schema.

The composition happens in the conversation. When you ask "does the case I cited in section II actually support the proposition I'm using it for, given what the record says about timing?" — that question needs the opinion (CourtListener), your record (Sound Suite), and the reasoning to hold both at once (Claude). The model calls both tools and does the joining.

This is a genuinely new shape. The old way to get two systems to cooperate was to build an integration between them: months of work, brittle, and obsolete when either side changes. Here the integration layer is the model's context window, and the cost of adding a third source is installing a third MCP server.

Citations, and the two ways they fail

The reason AI has a bad reputation in legal writing is specific and fair: models invent citations. Confidently, in correct format, for cases that do not exist.

Two different failure modes, needing two different guardrails.

Citations to the law

CourtListener ships a Citation Lookup and Verification API built for exactly this. Their own documentation describes it as a guardrail to "fight hallucinations in AI tools." It takes a block of text, parses every citation in it, and tells you which resolve to real cases.

So the check isn't "Claude, are you sure?" — a question a language model is structurally bad at answering. It's a lookup against a database of actual opinions. Either the citation resolves or it doesn't.

That distinction matters more than it sounds. Asking a model to self-assess its own confidence produces a number that feels like information and isn't. Asking a database whether a citation exists produces a fact.

Citations to your own record

The subtler failure. A model given your documents will summarise them accurately and then, three exchanges later, refer to that summary as though it were the document.

Nothing was hallucinated exactly. The claim just drifted from "the transcript says X" to "X," and the page number quietly fell off.

Sound Suite's answer is that retrieval is always citation-shaped. A result carries the document, the page, and — for transcripts — the line, because a reporter's record is organised around line numbers and a citation that can't reach them isn't much of a citation. The instructions that come with the tools push the model to quote and cite rather than paraphrase.

You still check. But you're checking a pointer rather than reconstructing where something came from.

Rules, in the same conversation

Procedural rules are the third leg. Deadlines, formatting, preservation, what an appellate court will and won't consider — these live in the same place as everything else, so "is this preserved for appeal, and what does the record show about when it was raised?" is one question rather than three separate lookups.

What it costs

This is the part that surprises people, so here is the arithmetic rather than an adjective.

Indexing your documents

Making documents searchable by meaning means turning text into embeddings — numerical representations that let a computer find passages by what they mean rather than which words they contain. It's the step that makes "find where they argued about timeliness" work when nobody wrote the word "timeliness."

Through OpenRouter, the embedding model Sound Suite defaults to runs about $0.02 per million tokens. A dense page of legal text is roughly 650 tokens.

A hundred thousand pages — a very large appellate record — costs about a dollar thirty to make semantically searchable. You pay it once, not per search.

Everything else

• Free Law Project — CourtListener's API is free to authenticated users at 125 requests per day, which is enough to work with. A membership raises the limits; if you run reports in cycles the way this post describes, you will want one.
• Claude — a normal subscription.
• Optional hosted inference — reranking and deep reasoning can run on your own GPU or route to a hosted model. Pennies for typical use, with per-role daily spend caps so it stays that way.

There is no per-seat legal-research platform fee in that list, and no per-search charge. That absence is the point.

Why it got fast

Speed mattered as much as cost. A loop you run a hundred times has to be quick, and one search stage was not: the cross-encoder reranker averaged about 115 seconds per call, with a 95th percentile of 117 seconds measured across 253 real calls.

The cause wasn't the model. Concurrent searches were queuing behind each other on a shared reranking pool. Capping that pool per call took the same operation to 4.8–7.1 seconds measured.

A search you wait two minutes for is a search you do once. A five-second search is one you do fifty times in an afternoon — which is what running a hundred and ten versions actually requires.

The connections

One capability deserves singling out, because it's what makes reports about arguments possible rather than reports about documents.

A motion is not a file in a folder. It is the centre of a small constellation: the response opposing it, the reply answering the response, the exhibits attached to each, the amended version, the order resolving it.

Sound Suite models those relationships explicitly. Select a motion in the Haystack Block View and you select everything connected to it — and a question asked in that scope is answered from the actual argument, both sides of it, in sequence.

That's what makes "what did they argue that I haven't answered?" a question a machine can attempt. It isn't matching words across a folder. It's walking from your motion to their response to your reply along relationships someone recorded.

If you want the reasoning behind that design — and why it borrows a data standard from building automation — that's its own post.

What this doesn't do

Worth being direct, because overclaiming here is how the technology earned its reputation.

It does not write your brief. It drafts, and it critiques, and the critiques are often sharper than the drafts. The judgement about which argument to lead with, what to concede, and how hard to push is yours. A model has no instinct for how a particular court receives a particular kind of argument.

It does not remove the duty to verify. Citation verification catches fabricated cases. It does not catch a real case cited for a proposition it doesn't support. That still requires reading the case.

It is not a shortcut around knowing your record. It's an amplifier. If you don't know what's in your file, faster search produces confident nonsense faster.

A hundred and ten versions is not automatically better than four. Iteration without judgement is noise. What the loop gives you is more chances to apply judgement — which only helps if you have some.

The actual shift

The interesting change isn't that AI can write legal prose. It's been able to produce plausible legal prose for a while, and plausible is the problem.

The change is that the three things a brief must be checked against — your record, the law, and the rules — can now all be interrogated from one place, in the time it takes to read the answer.

That turns drafting from a sequence of commitments into a loop. Four days, a hundred and ten passes, and a brief where every factual claim traces to a page and every citation resolves to a real case.

Not because the machine was brilliant. Because it was fast enough to ask a hundred and ten times.

Sound Suite runs on your own hardware; your documents are never uploaded. See the Claude Desktop setup guide to connect it, or the OpenRouter integration for running without a GPU.