The Legal Reasoning Harness
Why structure is what makes Legal AI trustworthy at the decision boundary
Every serious AI product ships with a harness: the layer of state, control and guardrails that turns a language model into something you can put in front of a user. Legal needs one built to a different standard, because every answer has to be defensible.
The general-purpose version of this is well understood, and the formula usually gets written as Agent = Model + Harness. Those harnesses are built to make agents capable: manage the loop, call the tools, hold the context. Legal work needs its infrastructure to do something harder, which is to ensure that a capable system is also a reliable one.
When a CLM or a Legal AI tool tells a lawyer that a termination right exists, that a liability cap applies, or that a notice obligation has been triggered, three things have to hold.
- The same contract and the same event must produce the same answer every time.
- The answer must explain which legal relation and which rule produced it.
- It must stay connected to the clause it came from.
Prompt variability, sampling and interpretive drift mean a language model cannot guarantee any of the three on its own, and the standard mitigations (better prompts, retries, validation passes, filters applied after the fact) narrow the range of outputs without solving the root issue.
What we built
Vichaara is a reasoning layer that sits between contract source material and the language models and Legal AI tools that consume it. We compile a contract once into a model of its legal relations: the structure and connections that capture what a contract actually does. Reasoning then runs over that model instead of over the text, so by the time a language model is involved its job is to write the sentence for a legal answer that has already been determined.
The model supports three kinds of questions:
- State evaluation. What obligations exist right now, who holds termination rights, what caps apply. Any question about what the agreement holds true at a given moment.
- Delta analysis. Given two drafts, what changed structurally: penalties raised, durations extended, control shifted, along with what those changes knock on to elsewhere in the agreement. Because the comparison runs at the level of legal structure, it surfaces changes that a text diff has no way to see.
- Event simulation. What happens when an SLA is missed, notice is given, or consent is withheld. An event goes in and the updated legal state comes back out.
Why this qualifies as a harness
Determinism is structural. Once a contract is compiled the legal model is fixed, and reasoning over a fixed model returns the same answer to the same question every time. We scope this deliberately. Vichaara resolves questions that have a structurally correct answer, and where a question turns on preference, strategy or genuine nuance, it surfaces the structure and leaves the judgment where it belongs.
Auditability is built into the architecture. Every conclusion is linked to the legal relation that supports it and back to the clause that gave rise to that relation, so the system can answer “why did it say that?” with the specific rule and source text involved.
Guardrails operate ahead of generation. Because legal reasoning and language generation are separated, a model producing prose from our structured output has no legal reasoning left to do and therefore nothing to drift on. Most harnesses screen output once it has been written; the constraint here applies earlier in the chain.
Legal impact and negotiation strategy remain distinct outputs. What a contract requires or permits is one question. What a party should do about it is a different one, and it depends on policy, risk appetite and relationships. Enterprises layer their own playbooks on top of what we return, and we keep that boundary explicit.
What this means if you are building on it
Vichaara is infrastructure, so how it integrates matters as much as how it reasons. Outputs come back into the interface your users already work in, which means there is no new UI to learn and no adoption curve to manage. The cost profile shifts as well, since the investment happens once at compile time and queries against the structured model are fast and cheap enough to run at volume. For platforms carrying token costs that climb with every seat added, that moves a meaningful share of the workload from variable cost to fixed.
What your customers get out of it is answers they can act on and defend, produced at a cost that holds up as usage grows.