Legal AI Tools 2026: 39% of the Clauses That Matter Sit in the Back Half
A legal AI demo runs on the first three pages of an NDA and looks excellent. I located every labeled clause inside 510 real commercial contracts to see how far that demo reaches: 39.4% of 6,702 clauses sit in the back half, and in 27% of contracts the governing-law clause is in the final tenth. A tool that stops at page 20 misses 14% of clauses overall and 23% of governing-law clauses.
📜 Table of Contents
A legal AI demo runs on the first three pages of an NDA and looks excellent: parties, term, a neat summary. The clauses that decide who pays sit twenty pages later.
I measured that distance on 510 real contracts instead of arguing about it. Where a clause physically sits is a property of a legal document a buyer can check before paying, and almost nobody checks it.
What I measured
The corpus is CUAD: 510 commercial contracts filed with the US SEC, 41 clause types, 20,910 question-answer pairs of which 6,702 carry a real annotation. 26.8 million characters in total, roughly 6.7 million tokens. I assumed 3,000 characters per page, conservative for 11-point text with one-inch margins, then located every annotation by character offset inside its own contract and divided by that contract's length. All figures below were computed on 7 November 2026, and the script at the end reproduces them on any export.
The typical document is not short: median 11 pages (8,300 tokens), 90th percentile 41 pages (30,700 tokens), longest 113 pages. The top tenth of the corpus runs past 40 pages.
The map of where clauses live
Median relative position inside the contract, and the share of instances that fall in the back half:
- Parties — 0.01, 4%
- Agreement Date — 0.01, 10%
- Effective Date — 0.01, 13%
- Termination For Convenience — 0.57, 60%
- Insurance — 0.61, 65%
- Cap On Liability — 0.67, 77%
- Change Of Control — 0.68, 69%
- Uncapped Liability — 0.69, 83%
- Anti-Assignment — 0.79, 88%
- Governing Law — 0.84, 93%
Across all 6,702 annotations, 39.4% sit in the back half and the median lands 36% of the way through. The quartile split is 41.9%, 18.7%, 20.8%, 18.6%, which is close to flat once you leave the first quarter.
One extreme case deserves its own line: in 119 of 437 contracts (27%) the governing-law clause appears in the final tenth of the text. That is also the clause an AI summary most often gets wrong, because a summary written from the front matter has nothing to copy from.
The order is a drafting habit
Commercial agreements are assembled in roughly the order they were negotiated: who the parties are, what the deal is, definitions, then obligations, then the risk-allocation block the legal teams fight over, then boilerplate. Governing law, notices, assignment and liability caps are drafted last and filed last. A pipeline that summarizes the first N pages reads the part that names people and stops right before the part that allocates money.
The page cap is the product
Coverage of annotations if a tool reads only the first 10, 20 or 40 pages:
- all clauses — 70%, 86%, 95%
- Governing Law — 48%, 77%, 92%
- Cap On Liability — 45%, 75%, 92%
- Uncapped Liability — 33%, 70%, 91%
- Insurance — 42%, 68%, 89%
- Renewal Term — 78%, 91%, 98%
A 10-page cap keeps 70% of clauses, and the missing 30% is not a random sample. It is the back of the document, which is where the liability and assignment language lives; uncapped-liability coverage drops to a third. The median annotation sits on page 4.3 and the 90th percentile on page 25.7, so long documents are the middle of this corpus rather than an edge case.
One document shows the size of the effect better than the aggregate. A 27.3-page strategic alliance agreement in the corpus carries eight of these clause types, and seven of the eight sit past page 19; the median cited page is 20.8. A tool reading the front half would have returned one of eight.
Why keyword search does not rescue it
Before trusting any vendor I ran my own baseline: ten plain regex patterns over all 510 contracts, scored per contract, meaning did the pattern fire somewhere in a document that actually contains that clause. Recall and precision:
- Governing Law — 82% / 98%
- Insurance — 100% / 67%
- Exclusivity — 98% / 44%
- Anti-Assignment — 51% / 98%
- Cap On Liability — 53% / 95%
- Change Of Control — 49% / 80%
- Termination For Convenience — 48% / 51%
- Non-Compete — 41% / 72%
- Most Favored Nation — 18% / 83%
- Uncapped Liability — 3% / 12%
The expensive clauses are the ones grep fails on. A liability cap is usually written "in no event shall either party's aggregate liability exceed", which contains neither "cap" nor the phrase "limitation of liability" in that order. An uncapped liability defines itself as the absence of a limit, so searching for the limit finds its opposite. That is the trap in the search-the-PDF-and-paste-it-into-chat workflow: the vocabulary of the remedy has little to do with the vocabulary of the risk. Three percent recall on the one clause that decides whether a breach is survivable is a false sense of coverage.
Chunking is the smaller problem
Context windows get blamed for everything. The arithmetic says otherwise. The median clause is 194 characters, no clause in the corpus is longer than a page, and only 8.5% of clauses straddle a 3,000-character boundary, 3.0% at 8,000 characters, 0.4% at 32,000. A chunker with modest overlap survives that. Coverage dies at the page cap and in summarize-first pipelines, and both of those are product decisions rather than model limits.
The other number worth holding: contracts here carry a median of 13 labeled clause types, 90th percentile 22, maximum 32. A tool that checks a fixed list of five risks covers less than half of the median contract however good the model is.
The acceptance test I use now
Six checks, an afternoon each on the vendor's own trial:
- Every finding returns clause name, page number and a verbatim quote. Then open the PDF at that page and read the quote. An output you cannot open is a paragraph of text with no evidentiary value.
- Feed it a contract whose governing law sits in the last five pages. If the summary never mentions it, the tool has a page window and the window is the product.
- Ask for a clause type the contract does not contain. "Not found" has to be an available answer, because a tool that always returns five findings is matching your question rather than the document.
- Run the same contract as PDF and as plain text. Page numbers should agree within one page. A gap of ten means the tool tracks characters and not pages.
- Put a liability cap across a page break and check that both halves get cited.
- Measure where its citations sit. The share past the half-way mark should land near the corpus figure of 39%. A number near zero means the tool reads the front and summarizes.
The script
Python 3.8+, standard library only. Export the contract to text, put the tool's quotes in a two-column CSV with the header clause,quote, then run python3 coverage_check.py contract.txt citations.csv.
import csv, re, sys, statistics as st
PAGE = 3000
def locate(text, quote):
q = re.sub(r"\s+", " ", quote.strip())
if not q:
return -1
rx = re.compile(r"\s+".join(re.escape(p) for p in q.split(" ")), re.I)
m = rx.search(text)
return m.start() if m else -1
text = open(sys.argv[1], encoding="utf-8", errors="ignore").read()
rows = list(csv.DictReader(open(sys.argv[2], encoding="utf-8-sig")))
hit, miss, pos = [], [], []
print("%-30s %5s %6s %s" % ("clause", "page", "pos", "found"))
for r in rows:
i = locate(text, r.get("quote", ""))
if i < 0:
miss.append(r["clause"])
print("%-30s %5s %6s NO - quote not in contract" % (r["clause"][:30], "-", "-"))
continue
pg, rel = i / PAGE + 1, i / len(text)
hit.append(pg); pos.append(rel)
print("%-30s %5.1f %5.0f%% yes" % (r["clause"][:30], pg, rel * 100))
n = len(rows)
print("\ncontract: %.1f pages (%d chars) | citations: %d | verified: %d (%.0f%%)"
% (len(text) / PAGE, len(text), n, len(hit), 100 * len(hit) / n))
if hit:
print("median cited page: %.1f | deepest: %.1f | citations past half: %.0f%%"
% (st.median(hit), max(hit), 100 * sum(1 for p in pos if p >= .5) / len(pos)))
print("front-half-only tool would have shown %d of %d verified clauses"
% (sum(1 for p in pos if p < .5), len(pos)))
if miss:
print("UNVERIFIED: %s" % ", ".join(miss))On a 27.3-page strategic alliance agreement from the corpus, with eight clause quotes taken from the annotations, it prints:
clause page pos found Governing Law 27.9 98% yes Cap On Liability 19.7 68% yes Anti-Assignment 26.6 94% yes Change Of Control 21.0 73% yes Insurance 19.5 68% yes Termination For Convenience 21.2 74% yes Expiration Date 20.6 72% yes Parties 1.1 1% yes contract: 27.3 pages (81926 chars) | citations: 8 | verified: 8 (100%) median cited page: 20.8 | deepest: 27.9 | citations past half: 88% front-half-only tool would have shown 1 of 8 verified clauses
The "found" column matters as much as the page numbers. A quote that does not appear in the text is a paraphrase dressed as evidence, and one run of the script catches it.
What these numbers do not tell you
Position is not correctness. A tool can cite the right page and misread the clause, and none of the six checks will catch a wrong conclusion drawn from a correct quote. CUAD is 510 English-language US commercial contracts from SEC filings: no litigation filings, no civil-law jurisdictions, no leases or employment agreements. The 3,000-character page is an approximation, and a scanned or two-column PDF converts differently. The corpus is public, so every figure here can be re-run instead of believed.
If the open question is which tools to try rather than whether one works, the free options are compared here: eight free and open-source legal AI tools for research and review, and the contract-review shortlist with page-level output sits here: five free contract review tools.
Written by our editorial team; tools listed here are tested or verified against public sources. Links point to official sites or GitHub repos for reference only — no paid placements.