A contract-review engine that shows its work

A global consulting firm processes thousands of contracts a year. Most of them are routine: standard NDAs, standard master service agreements, the same terms the legal team has approved a thousand times. A small share carry real risk and deserve senior attention. But in most legal functions, both go through the same queue at the same speed. A standard NDA waits behind a complex acquisition, and the reviewer reads every line of both, hunting for the same handful of deviations they have flagged countless times before.

This is expensive in two ways. Deals slip while routine paper sits in a queue. And expensive expertise gets spent on pattern-matching that does not need it. The firm did not need more lawyers. It needed leverage on the routine work so the senior people could spend their time on the exceptions.

We rejected the black-box approach that says "this contract is safe" and asks you to trust it. In an enterprise, trust requires an audit trail. When a General Counsel asks why a contract was approved, "the AI said so" is not an answer. So we built a system that works like a fast, tireless junior associate that shows every step of its reasoning.

It works in four stages. It extracts the clauses that matter: indemnification, limitation of liability, termination rights, IP assignment. For each flagged clause, it captures the exact language that triggered the flag, the actual words, not a paraphrase. It maps every clause against the firm's own risk taxonomy, comparing incoming paper against their standard positions and marking where it deviates. And it is built with a hard rule: if the system cannot cite a specific clause in the contract, it marks the response "requires human review." No citation, no claim.

The output is a green lane. Low-risk, standard contracts get a fast, sourced approval. Anything that deviates gets routed to a human with the deviation already identified and the triggering language already pulled. The reviewer starts from the exception, not from page one.

Building this for production meant confronting where the technology actually breaks.

The first problem was confidence without accuracy. The model sounds equally certain whether it is right or wrong, and fluency does not track correctness. Our answer was structural, not a better prompt: we hard-coded verification requirements and a gating system so that a confident-sounding output cannot pass without a citation to back it.

The second problem was stranger. Advanced reasoning models would sometimes refuse to engage with complex liability questions, tripping safety filters that had nothing to do with the actual task. We solved it by decomposing the work into discrete steps, isolate the clause, extract the evidence, assign the risk level, rather than asking the model to do all three at once. Breaking the cognitive load into stages both bypassed the refusals and raised accuracy.

The value here is not the AI output. It is where the handoff happens between machine and human. The engine does the pattern recognition at scale: structured, auditable, fast. The reviewer does the judgment: the exceptions, the negotiations, the calls that carry real consequence. The design question was never how smart we could make the model. It was where to draw the line between what the machine handles and what a person should.