Rigor for the age of legal machines.

Every legal proposition a machine hands to a lawyer carries an unstated promise: that it can be relied on. For most of the short history of generative legal AI, that promise has been tested in exactly one way, by asking whether the cited case exists. The test was necessary. It was never close to sufficient. This manifesto explains why we believe computational law must be practiced as a discipline with its own standards, what we refuse to accept from legal machines and from the people who build them, and what we commit to doing instead.

Our charter states the aim directly:

The Computational Law Institute exists to turn fifty years of legal reasoning theory into standards the profession can test, rerun, and rely on. Its mission is to define what "filing-grade" means for machine-assisted legal work and to measure it in the open: not merely whether an AI system fabricates citations, but whether it finds the controlling authority, surfaces the adverse precedent, confirms that a holding is still good law, and shows the exact reasoning path from precedent to conclusion.

Why computational law needs its own discipline

Computational law is older than most of the people now selling it. Layman Allen proposed normalizing statutory language into logical form in 1957. L. Thorne McCarty built TAXMAN to reason about tax law in 1977. A British team translated the British Nationality Act into Prolog. Ashley's HYPO modeled argument with cases, dimensions and hypotheticals; CATO made factors side-relative, so that a fact could favor one party and not the other. Prakken and Sartor formalized defeasible, adversarial argument. Horty and Bench-Capon formalized how precedent constrains. The theory specified, with real precision, what legal reasoning requires: propositions with a direction, rules with types, precedent with structure.

What reached lawyers at scale was something else. Editorial topic systems, citators, and, in the last few years, retrieval pipelines that pass text to a language model. Production happened where law is rule-like. Case law reasoning, where relevance is decided by analogy and analogy is contested, stayed in the lab.

That gap is why we think computational law needs its own discipline rather than a seat in someone else's. The questions it asks do not belong cleanly to computer science or to law. An engineering team can measure whether a retrieved passage is relevant to a query. It cannot decide whether a holding announced on a summary judgment record transfers to a motion confined to the pleadings. A good lawyer can decide that in a minute. What the lawyer cannot do is state the decision as a test that runs, identically and auditably, across millions of propositions. The discipline lives in between: it takes the judgments lawyers make about whether law is usable and turns them into representations, protocols and measurements that anyone can inspect. Neither parent field's native metrics fit the job. A retrieval score does not know what a holding is, and "it reads well" is precisely the signal fluent machines have learned to fake.

Why now

The failures are documented, and they are public. In 2023, in Mata v. Avianca, a federal judge in New York sanctioned a law firm $5,000 after two of its attorneys filed a brief citing six cases that ChatGPT had invented. A public database maintained by a researcher at HEC Paris now lists more than two thousand decisions in which a court or tribunal has addressed the use of AI. In 2026 the Sixth Circuit fined two attorneys $15,000 each, plus fees and double costs, over briefs containing fabricated and misrepresented citations. Peer-reviewed testing of commercial retrieval-augmented research tools found them hallucinating between 17 and 33 percent of the time.

The profession's answer has been to verify citations. That is the right answer to the failure it can see. But the failure is moving. A system that retrieves from a real corpus and never lets the model write a citation can drive fabrication to zero, and the errors that remain are harder to see because every citation in them is real:

• The wrong stage. A summary judgment holding that the plaintiff "offered no evidence" of an element, cited in a motion that tests only the pleadings. Twombly's plausibility standard, cited against a California demurrer that is governed by the state's fact-pleading statute.
• The missing controlling authority. The case that decides the question in this forum was never retrieved, so it never entered the draft, so no checker ever saw it.
• The adverse authority. The exception to the rule, sitting on the same page of the opinion the brief relies on, and the cure path the other side will ask the court to take.
• Stale law. An intermediate appellate opinion reversed last month, or placed under review, or superseded by statute, handed over as clean because nothing in the pipeline represented its later history.

None of these is a hallucination. Each passes a citation check. Each can lose a motion. And the instrument the profession relies on for currency is less settled than it looks: in one study of 357 citing relationships that at least one major citator flagged as negative, the three services all agreed that negative treatment existed in only 53.

There is a second reason the moment matters. For decades the bottleneck in computational law was engineering: the theory assumed structured input that nobody could produce at scale. Language models can now extract propositions from opinions across an entire published corpus, well enough to be checked, and graph infrastructure can store and query what they extract. The old specification has become buildable. That makes it urgent to agree on what a correct build must do before the market settles the question by default.

What we reject

False certainty, and its most dangerous form, hallucinated certainty. A fabricated case announces itself: opposing counsel cannot find it, and a citator will not recognize it. A genuine circuit split presented as settled law announces nothing. Every cited case is real, every quotation accurate, and the client is advised as if the question had one answer when the courts have given two. We distinguish shallow ambiguity, a gap in the researcher's knowledge that more research can close, from genuine ambiguity, a gap in the law itself. A system that cannot tell the difference will smooth the second into the first, and it will sound most confident exactly where confidence is least warranted.

Black-box legal outputs. Lawyers are right to extend no default trust to a machine. Trust has to be earned by reasoning that can be reconstructed: which question was asked, what was searched, what was retrieved, what was rejected and why, and which recognized mode of inference carries each authority to each conclusion. An answer that cannot be traced cannot be defended, and a confidence percentage attached to an untraceable answer is decoration.

Verification as a checkbox. A citation verifier is a smoke alarm. Every building should have one, and no building was ever built by one. A checker reads the document, so it can never check the citation that is not there. Its arithmetic is unforgiving: at a 2 percent miss rate across 35 cited propositions, fewer than half of briefs pass clean. Used as an inline gate, it rewards the cheapest way to pass, which is to cite less. And a partial control experienced as a total control can make people worse at catching what it misses, the irony Lisanne Bainbridge described in 1983 and four decades of human factors research have confirmed. We do not reject verification. We reject mistaking it for architecture.

Benchmarks that grade only what is present. A benchmark that scores the citations in an answer inherits the verifier's blind spot. In our survey of public legal AI benchmarks, none measured failure to retrieve controlling authority. A single averaged score makes it worse, because a tool that never fabricates and routinely misses the controlling case will average well while losing motions.

What we commit to

The charter names four commitments. Stated concretely:

1. Open, rerunnable benchmarks with public rubrics. We grade omission alongside accuracy: controlling authority omitted, adverse authority surfaced, posture mismatches, element coverage, and fabricated or misgrounded citations, reported side by side and never averaged into one number. Rubrics are fixed before a run. Rows where a system under test looks strong stay in the table, because near-parity where competitors are good is what makes a gap elsewhere credible. Where we can, we use adversarially produced ground truth: a decided motion, with its opposition, reply and order, is an answer key built by two motivated sides and graded by a judge.
2. Shared formal vocabularies. We publish vocabularies for holdings (the proposition, its stance, its origin, the stage and standard under which it was announced), for treatment (scope, severity and mechanism, attached to holdings rather than whole cases), and for the recognized modes of legal inference, the bridges by which authority lawfully travels from a decided case to a new one. A "therefore" that rests on no recognized bridge is advocacy, not law. With a shared vocabulary, reasoning can be audited rather than trusted.
3. Reliability designed in, not inspected in. Generators never originate citations. Stages that handle citations contain no generative models, and generative stages emit no citations. Guarantees live in code, not in prompts. A system must be able to halt without producing a confident output, and filings should travel with a derivation record of how they were made.
4. A public record of AI citation failures in court. We keep that record, classify failures beyond fabrication, and publish it so that bar associations, judges and malpractice carriers can set policy on evidence rather than anecdote.

Behind those commitments sit the positions that organize our research programs.

Surface uncertainty. Every output should say which kind of uncertainty it reports. Where we measure the openness of a contested ruling, as in Ariadne's Thread, we hold verified law fixed, vary only judicial posture, subtract the instrument's own noise, report an interval rather than a bare number, and abstain when the signal does not clear the noise floor.

Proposition usability over good law. "Is this good law?" is a question about cases. The lawyer's question is about propositions: is it still valid, does it govern in this forum and posture, whom does it help, and has it already been rejected here? We teach, test and build to those four questions.

Outputs that are explainable, grounded, testable and versioned. These are the Four Laws of System Design for Computational Law, ordered so that the higher law controls: no output presented with more confidence than the system can defend; no output the system cannot explain; no proposition not grounded in validated authority; no reasoning component that cannot be tested in isolation and versioned.

Law as a versioned codebase. Enacted law behaves like a main branch, opinions like signed commits, dissents like preserved branches. Overruling is a force push, and it should require gated conditions: the error named, reliance addressed, the new reading reasoned. We hold our own frameworks and theses to the same discipline, with version numbers and changelogs.

Adversarial reasoning as a first-class function. Direction is a property of a holding, not of a case. An opposition system must build the counter-model, a signable account of why the motion fails, rather than a list of objections under the movant's headings. Searching for the rejection of an argument is a different search from searching for the rule, and a system that runs only the second will miss the case the other side is going to cite.

What automation changes about judges and lawyers. "Can a machine replace the judge?" is the wrong question. A decision combines mechanical verification of legal premises with discretionary calibration of process: how willing a judge is to end a case early, where the filter bites, how much fact development is allowed. Machines can take much of the first. The second remains, and it deserves rigorous description rather than either denial or panic. For lawyers, the judgments a signature warrants cannot be quietly absorbed by software. A system that does so has not automated the work. It has transferred the malpractice.

How we work

Our method is a loop with five steps.

1. Observe a failure in practice or in a legal machine: a summary judgment case cited in a demurrer, a green citator flag on a proposition that no longer governs, an agent that keeps working after its work is done.
2. Theorize it into a claim precise enough to be wrong: right law at the wrong stage is wrong law.
3. Formalize the claim into a framework or protocol: a taxonomy of standard, record, burden and forum mismatch, with a pre-filing test for each.
4. Test it in code, data or a controlled experiment, and label the result honestly. The formal properties of a metric are theorems; claims about real dockets are conjectures until evidence arrives. When an engineered fixture is only a demonstration of mechanics, we say so. When a validation gate fails, as the elusion and calibration gates did in our blind eDiscovery review, the failure is published with the result.
5. Publish and version it: a stable URL, a revision history, a changelog, and the humility to retire a claim when the evidence turns against it.

We build on open law and publish our methods so that anyone can rerun them. Our founder also founded Legawrite.AI, and some systems we discuss were built there. That is a reason for more openness, not less. We state our standards so that those systems, like any others, can fail them in public, and we disclose the relationship wherever it bears on a piece.

The Theses

The positions above are compressed into numbered Theses. Each thesis is a short, citable claim with a defense, the work that supports it, the date it was first stated and a revision history. They are meant to be argued with. If one is wrong, we would rather learn it from a replication than from a sanctions order.

We end where the charter ends: in a profession that answers to judges, a standard only matters if anyone can check it.