This one started with a document I nearly signed myself. A one-page research consent form, the kind you skim for four seconds and accept. Reading it properly afterwards, it granted perpetual, irrevocable, worldwide rights to my name, voice and likeness, with no way to revoke consent after withdrawing from the study, and a liability release with no carve-out for gross negligence. None of it was hidden. I simply would not have read it.
That gap is not a knowledge problem, it is an economics problem. A lawyer costs money per hour, and the contract in front of you is usually routine enough that paying for a full review feels absurd. So freelancers accept client agreements without checking the IP clause, small business owners sign leases with auto-renewal buried on page thirty, and everyone clicks accept. The existing AI options did not help much either, because a general-purpose summary paraphrases a contract rather than telling you which parts of it are dangerous.
The first design decision was retrieval over summarisation. Handing an entire forty-page agreement to a language model and asking what is risky produces confident, fluent output that is very hard to verify. Instead the contract is chunked, embedded, and searched, so the model only ever sees excerpts actually pulled from the document. Every flag it produces points at real words in the contract, which means a finding can be checked rather than trusted.
The second decision was a fixed question set rather than an open prompt. Eight standard questions run against every contract: termination and notice, payment terms, IP ownership, liability and indemnification, confidentiality, dispute resolution and governing law, non-compete restrictions, and renewal. Asking the same eight things every time makes two contracts comparable, and it stops the analysis drifting toward whatever happens to be prominent in the text.
The third was confidence banding, which exists specifically to stop the model filling gaps. Explicit contract language scores 0.9 and above, implied terms 0.7 to 0.8, and genuine inferences 0.5 to 0.6. Anything the model is less sure of than that is omitted rather than guessed. A brief that says "not found" for governing law is more useful than one that invents a jurisdiction.
Chunk size mattered more than expected. Legal meaning lives in whole clauses, and a limitation of liability that gets separated from its carve-outs reads as a completely different provision. Chunks are 800 words with 150 words of overlap so that clauses straddling a boundary survive intact.
Tested against a forty-five page commercial agreement pulled from SEC filings, the pipeline handled 20,503 words split into thirty-two chunks and retained the twenty most relevant. That is the run where retrieval stops being decorative. On a short document everything gets passed through regardless, but at that length the system is genuinely deciding what matters and discarding the rest.
On the consent form that prompted the build, it returned eight flags. The three graded highest were the one-sided confidentiality obligation, the perpetual and irrevocable rights grant, and the liability release with no carve-out for gross negligence. Those are the same three a lawyer flags first on that document, and each one arrived attached to the clause it came from.
The design choice that matters most in practice is what the tool refuses to do. Where the contract is silent, the brief says "not found" rather than producing a plausible answer, and the questions-to-ask section turns those gaps into something actionable. The output is triage before legal review, not a replacement for it, and the shareable link exists precisely so the next step can be a lawyer looking at three specific clauses instead of forty pages.
Book a free 30-minute discovery call. I'll map your current workflow and show you exactly what's possible.
Book a call See other case studies