Every company has a renewal cycle — a moment each year when a pile of supplier contracts comes due and someone in legal has to decide which ones need attention. For most in-house teams, that decision gets made the same way it always has: a lawyer reads each contract, flags the issues, and routes it accordingly. Thorough, but slow. At 30–45 minutes per contract, 200 renewals is six to eight weeks of a lawyer's time before a single negotiation has started.
Sophie was a legal ops manager at a UK retailer with exactly this problem. 200 supplier contracts — varying from two-page service agreements to 40-page framework contracts — all due for review before the end of the quarter. Her team had two in-house solicitors and no budget for external counsel at that volume.
She needed a way to triage: identify which contracts had genuine risk flags that warranted full lawyer attention, and which were standard-form agreements that could be renewed with a quick sign-off. AI batch processing gave her a first pass that made the lawyer time go five times further.
Important caveat before we start: AI is not a lawyer. The output described here is a structured checklist — it flags what to look for and where to look, not legal advice about what it means. Every flagged item still required a qualified solicitor to assess. The value is in triage: making sure lawyers spend time on the contracts that need them, not on contracts that don't.
What the pre-screen was looking for
Sophie worked with her solicitors to define the checklist before building the spreadsheet. This was the most valuable hour of the project — getting alignment on exactly what a "flag" meant before any AI was involved.
They settled on eight checks per contract:
- Governing law — which jurisdiction? Non-UK governing law needs a solicitor review.
- Liability cap — is there one? Is it mutual? Note the amount or formula.
- Auto-renewal clause — yes/no. If yes, note the notice period required to exit.
- Termination for convenience — can either party exit without cause? Note notice period.
- IP ownership — who owns work product or IP created under the contract?
- Data processing — does the contract involve personal data? Is a DPA referenced or included?
- Unlimited liability carve-outs — any clauses that exclude the liability cap (e.g. fraud, IP infringement, death/injury)?
- Overall risk flag — LOW / MEDIUM / HIGH — based on the above, how urgently does a solicitor need to read this?
Defining the checklist first meant the prompt was essentially already written. The eight checks became eight output fields.
Building the spreadsheet
Sophie exported each contract as plain text — most were already in Word format, so a simple Save As gave her the text. She pasted the full contract text into a single column, one row per contract.
| supplier_name | contract_type | contract_text |
|---|---|---|
| Meridian Logistics Ltd | Supply Agreement | [full contract text — typically 2,000–8,000 words] |
| Apex Software Solutions | SaaS Subscription | [full contract text] |
The contract_type column wasn't used by the model directly, but helped her filter and sort the output afterwards — liability cap norms differ significantly between a logistics agreement and a software subscription.
A note on length: PromptMax sends the full row to the model, and long contract texts do consume more tokens — which affects cost. At an average of 5,000 words per contract, 200 contracts is roughly 1M input tokens. Still affordable, but worth knowing before you run the batch.
Writing the prompt
Prompt used:
You are a legal document analyst supporting an in-house legal team. Review the contract_text below and complete the following checklist. Output exactly this format — no preamble, no legal advice, no commentary beyond what is asked:
GOVERNING_LAW: [jurisdiction, e.g. "England and Wales" — or "NOT FOUND" if absent]
LIABILITY_CAP: [amount or formula if present, "UNCAPPED" if no cap, "NOT FOUND" if absent]
AUTO_RENEWAL: [YES (note notice period to exit) / NO / NOT FOUND]
TERMINATION_CONVENIENCE: [YES (note notice period) / NO / NOT FOUND]
IP_OWNERSHIP: [brief note on who owns work product/IP, or "NOT ADDRESSED"]
DATA_PROCESSING: [YES — DPA referenced/included / YES — no DPA / NO / NOT FOUND]
UNLIMITED_LIABILITY_CARVEOUTS: [list any clauses excluded from the liability cap, or "NONE IDENTIFIED"]
RISK_FLAG: [LOW / MEDIUM / HIGH]
Risk flag guidance:
HIGH — non-UK governing law, uncapped liability, missing DPA where personal data is involved, or unusual carve-outs beyond standard (fraud, IP, death/injury)
MEDIUM — auto-renewal with short notice period (<30 days), IP ownership unclear, termination for convenience absent
LOW — standard terms, UK governing law, mutual liability cap, DPA present if needed
Two design choices that made a significant difference:
Explicit "NOT FOUND" as a valid output. Without this, models tend to either guess or stay silent on absent clauses. Forcing NOT FOUND as an option means the output distinguishes between "this clause is absent" and "this clause is present but not flagged" — a meaningful difference for triage.
Defined risk flag criteria. Without the guidance section, the model clustered most contracts at MEDIUM. Defining what HIGH, MEDIUM, and LOW mean — with specific examples — produced differentiated, actionable triage scores.
Running the batch
200 rows on Claude Sonnet 4.6. Contract analysis requires reading carefully and reasoning across long, dense text — this is exactly the kind of task where Claude's reading quality pays for itself. The cost difference between Haiku and Sonnet on 200 long contracts is modest; the quality difference on nuanced clause identification is not.
The batch completed in just under three hours — Anthropic's batch API processes in the background, so Sophie set it running at the end of the day and had results by morning.
What the output looked like
| supplier_name | AI responses (excerpt) |
|---|---|
| Meridian Logistics Ltd | GOVERNING_LAW: England and Wales LIABILITY_CAP: £500,000 per claim, mutual AUTO_RENEWAL: YES — 90 days notice to exit TERMINATION_CONVENIENCE: YES — 30 days notice IP_OWNERSHIP: All IP remains with supplier; licence granted to client DATA_PROCESSING: NO UNLIMITED_LIABILITY_CARVEOUTS: Fraud, wilful misconduct, death/injury (standard) RISK_FLAG: LOW |
| Apex Software Solutions | GOVERNING_LAW: Delaware, USA LIABILITY_CAP: UNCAPPED on client's payment obligations AUTO_RENEWAL: YES — 14 days notice to exit TERMINATION_CONVENIENCE: NO IP_OWNERSHIP: NOT ADDRESSED — work-for-hire clause absent DATA_PROCESSING: YES — no DPA referenced or included UNLIMITED_LIABILITY_CARVEOUTS: Client indemnity for IP infringement — broad, no cap RISK_FLAG: HIGH |
How the output was used
Sophie sorted the 200 results by RISK_FLAG. The breakdown:
- HIGH (23 contracts): Routed immediately to a solicitor with the AI checklist as a reading guide — "start with the governing law and the liability cap sections." Average lawyer time per contract dropped from 45 minutes to 20, because they already knew where the issues were.
- MEDIUM (61 contracts): Reviewed by Sophie herself using the checklist, with escalation to a solicitor for specific clauses flagged as unusual. Most resolved without full legal review.
- LOW (116 contracts): Renewed with a one-page sign-off memo noting the key terms. No solicitor time required.
Total solicitor time on the 200 contracts: roughly 60 hours, down from a projected 125. The AI pre-screen didn't replace legal review — it concentrated it where it was needed.
What to watch out for
The model can miss things. Contract language is dense and sometimes deliberately ambiguous. The pre-screen caught the obvious flags; it didn't catch everything a careful solicitor would. All HIGH contracts still got a full read. None of the LOW contracts were treated as reviewed — they were treated as screened.
Very long contracts hit token limits. Three contracts in the batch exceeded the model's context window and came back with partial output. Sophie processed those manually. For contracts over ~30 pages, consider extracting only the key sections (definitions, liability, termination, governing law) rather than passing the full text.
The checklist design is the work. The batch job is fast. Defining what you're looking for — and what HIGH means versus MEDIUM — is where the time goes. That's not a limitation; it's the right approach. The checklist captures your legal team's actual standards, applied consistently to every contract.