Contract Analysis with Document Intelligence

Key facts, with sources

• Box, citing industry estimates in line with IDC and Gartner figures, puts unstructured content at about 90% of enterprise data, most of it locked in documents, emails, and images. (Box)
• Mistral OCR 3 is priced at $2 per 1,000 pages, dropping to $1 per 1,000 pages with the batch API, putting large-archive parsing in commodity price territory. (Mistral AI)
• Mistral OCR 4 scored 93.07 on OmniDocBench and a top overall 85.20 on OlmOCR-Bench, and Mistral reports accuracy equivalent to leading agentic document parsers at roughly 8x lower cost and 17x lower latency. (Mistral AI)
• OmniDocBench, the CVPR 2025 document parsing benchmark, evaluates text, table, formula, and layout accuracy across 981 PDF pages spanning nine document types including handwritten notes and dense newspapers. (arXiv)
• An NVIDIA chunking benchmark across five datasets found page-level chunking achieved the highest average retrieval accuracy at 0.648, with up to a 9% recall gap between the best and worst chunking strategies. (Firecrawl)

What contract analysis extracts

The first job is turning prose into structured data. From each contract, an AI pipeline pulls the terms a reviewer always looks for: the parties, effective and expiry dates, payment terms and amounts, termination and notice provisions, liability and indemnity, confidentiality, governing law, and auto-renewal. Put into a defined schema, these become searchable, comparable, and reportable across a whole portfolio of contracts — 'show me every agreement that auto-renews in the next 90 days' becomes a query instead of a week of reading.

Structure is what makes the output usable and auditable. A free-text summary reads well and hides errors; a typed field for 'termination_notice_days' either has the right number or a flag saying it could not find one.

Risk flagging against a playbook

Extraction tells you what the contract says; risk flagging tells you what to worry about. Every legal team has a playbook — preferred positions and red lines on liability caps, payment terms, indemnity, unilateral termination, and the like. The AI compares the contract's clauses against that playbook and flags where the language is non-standard, one-sided, or riskier than your baseline, so the reviewer starts with the parts that matter instead of reading linearly from page one.

The point is prioritization, not verdicts. A good system says 'this liability clause is broader than your standard, look here'; it does not say 'this contract is approved.' That judgment stays with a person.

The 'missing clause' problem

The most dangerous risk in a contract is often not a bad clause but an absent one — no liability cap, no confidentiality provision, no termination-for-convenience right. This is exactly what tired human reviewers miss, because it is hard to notice something that is not there. It is also where AI helps most: checking a contract against a checklist of expected clauses and flagging what is missing is a task machines are genuinely good at and humans are genuinely bad at.

Designing for absence — asking 'which of our standard protections are not in here?' — is one of the highest-value things a contract-analysis system does, and it is easy to overlook if you only think in terms of extracting what is present.

Human-in-the-loop: accelerate, don't replace

The safe and effective design is assistive: the AI extracts, flags, and prioritizes; the lawyer reviews, corrects, and decides. Confidence and reconciliation route the work — high-confidence extractions are presented for a quick confirm, low-confidence or high-stakes ones are surfaced for careful review. The reviewer is faster because the reading is guided, not because the reading is skipped.

from pydantic import BaseModel

class RiskFlag(BaseModel):
    clause: str            # e.g. "limitation_of_liability"
    finding: str           # what was found, or "MISSING"
    severity: str          # "high" | "medium" | "low"
    playbook_rule: str     # the standard it was compared against
    location: str          # page / section, so the reviewer can verify
    confidence: float

def needs_human(flag: RiskFlag) -> bool:
    return flag.severity == "high" or flag.confidence < 0.8 or flag.finding == "MISSING"

Accuracy, confidentiality, and when to hire

Two constraints shape every real deployment. Accuracy: extraction is strong on standard, well-formatted contracts and weaker on unusual drafting, scans, and dense legalese — which is why the human-review layer is not optional. Confidentiality: contracts are sensitive, so data handling, access control, and where the documents and model calls run are first-class design decisions, not afterthoughts.

This is a domain where the assist is enormously valuable and the autonomy is dangerous, so the engineering that matters is the extraction schema, the playbook comparison, the missing-clause checks, and the review workflow — plus getting the confidentiality right. That combination is where bringing in someone who has built document-intelligence systems pays off, because the failure modes here are quiet and costly.

When to hire senior help

Document pipelines fail in the long tail of formats, so senior help is most valuable after the prototype, when accuracy on real production documents must go from roughly 80% to reliably usable through validation rules, fallbacks, and human-in-the-loop design. Experienced practitioners also benchmark parsers on your actual documents before committing, which regularly changes tool choice and prevents costly re-processing later. If your stack includes React Native + Python + AI, a senior engineer who owns the full product beats coordinating multiple juniors.

Bottom line

Dhairya Senjaliya ships RAG — Document Intelligence projects worldwide — book a scoping call to discuss your specific situation.

Common pitfalls to avoid

• ✕Running scanned PDFs through a plain text extractor so tables collapse into word soup before they ever reach the retriever.
• ✕Evaluating a parser on clean digital PDFs when production traffic is scans, handwriting, and stamps, where published accuracy drops hardest.
• ✕Chunking by fixed token count straight across page and table boundaries, splitting table headers from the rows they describe.
• ✕Choosing an agentic parsing pipeline that costs 8x more per page for documents where a commodity OCR model at $1 to $4 per thousand pages would score the same.

Frequently asked questions

Sources

• Box
• Mistral AI
• Mistral AI
• arXiv
• Firecrawl