How to Analyze a Contract with AI (and Verify Every Clause)

AI contract analysis is only useful if you can check the answer. A summary that says "this agreement auto-renews annually" is worthless on its own — you need to know which file it came from, which section, and what the clause actually says. This guide walks through a repeatable workflow for analyzing a contract with AI, and, more importantly, for verifying every clause it hands you before anyone acts on it.

It is written for the people who actually do this work: in-house counsel and legal ops, procurement and vendor managers, founders reading their own MSAs, and finance teams trying to find out what they signed. No legal advice here, and none from the AI either. The goal is narrower and more honest: find what your documents say, faster, and prove it.

What AI contract analysis actually means (and what it doesn't)

Strip away the marketing and there are two very different things being sold under the same name.

Generative summarization. You paste a contract into a general-purpose chatbot and ask what it says. The model reads the text and produces fluent prose. It is fast, it is often roughly right, and it has no obligation to tell you where anything came from. When the contract is silent on a point, a model like this will frequently produce a plausible-sounding clause anyway, because producing plausible text is what it was trained to do.

Grounded retrieval with citations. The system indexes your documents, retrieves the passages that are actually relevant to your question, answers only from those passages, and attaches a citation to each claim so you can open the source. When the retrieved passages do not contain the answer, a well-built tool says so.

For contracts, only the second one is defensible. The difference is not academic. "The liability cap is 12 months of fees" and "the liability cap is 12 months of fees — Section 11.3, MSA_Acme_2024.pdf: 'in no event shall either party's aggregate liability exceed the fees paid in the twelve (12) months preceding the claim'" are the same sentence with wildly different value. One is a lead. The other is evidence.

FileAI is built for the second pattern: every answer carries a numbered citation that opens the exact passage in the source agreement, and it says the documents don't cover something rather than inventing a clause. You can see the full picture on the contract analysis use case page.

Before you start: assemble the whole agreement, not one file

The single most common failure in AI contract analysis is not a model error. It is an input error: analyzing one PDF when the actual agreement is five documents.

A real commercial relationship usually consists of:

• the master agreement (MSA, MSSA, framework agreement)
• one or more order forms, SOWs, or schedules that set price and term
• exhibits and annexes (SLA, security addendum, DPA)
• amendments, which silently override clauses in the master
• the NDA that came first and may still govern confidentiality

If you ask "when does this terminate?" while only the MSA is loaded, you will get the MSA's answer, cited correctly, and it may still be wrong for your situation because Amendment 2 changed the notice period from 90 days to 30. The citation was honest; your file set wasn't complete.

So step zero: gather every file that forms the agreement into one folder before you ask anything. Signed PDFs, Word drafts, exported redlines — FileAI reads PDF, DOCX, PPTX, TXT, Markdown, JSON, and HTML, so you rarely need to convert anything first. Name files so a human can tell them apart at a glance (MSA_Acme_2024.pdf, Acme_Amendment_2_2025.pdf), because those filenames are what you will see in citations.

Step 1: Start with an inventory question, not a hard one

Resist the urge to lead with the question you care about. Start by asking the AI to tell you what it is looking at:

List every document in this folder, and for each one give the parties, the effective date, and the document type (master agreement, order form, amendment, exhibit).

This takes fifteen seconds and does three useful things. It confirms the files parsed correctly — a scanned agreement with no text layer shows up here as suspiciously empty. It confirms you have the amendment chain. And it tells you whether the party names are consistent, which matters when a contracting entity is Acme Technologies Ltd in one file and Acme Tech Inc. in another.

If the inventory looks wrong, stop and fix the inputs. Everything downstream inherits this.

Step 2: Ask the questions that actually decide things

Good contract questions are specific, name the outcome you care about, and ask for the source. Vague questions get vague answers. Here are the ones worth asking on almost any commercial agreement.

Term, termination and notice

When can either party terminate this agreement, on what notice, and does termination for convenience exist? Quote the clause and give the section number.

Auto-renewal

Does this agreement auto-renew? If so, what is the renewal term and what is the deadline to give notice of non-renewal? Calculate the notice deadline from the effective date.

Auto-renewal is the clause that costs real money, because the deadline passes quietly. Ask for it on every contract, every time.

Liability

List every limitation of liability and every carve-out from that limitation, with the section each appears in.

The carve-outs matter more than the cap. A 12-month cap with uncapped indemnity, confidentiality, and data-breach exposure is not really a 12-month cap.

Indemnification

Who indemnifies whom, for what, and are there any caps or conditions on the indemnity?

Payment

What are the payment terms, the invoicing cadence, late-payment interest, and any price-increase or uplift mechanism?

Confidentiality and data

What are the confidentiality obligations and how long do they survive termination? Is there a data processing addendum, and what does it say about sub-processors and deletion?

Assignment and change of control

Can either party assign this agreement, and what happens on a change of control?

That last one gets ignored until an acquisition makes it urgent. Ask it early.

Notice that each question asks for the section or the quote. That instruction is not cosmetic — it shapes what a grounded tool retrieves and gives you the hook you need for the next step.

Step 3: Verify every clause before you rely on it

This is the step people skip, and it is the entire point. Treat every AI answer as a lead, not a finding, until it survives four checks.

1. Open the citation. Click through to the source passage. Do not read the summary's paraphrase — read the clause. If the tool cannot show you the passage, you have no basis to trust the claim, and you should not pass it on.

2. Check the file. Confirm the citation points at the document you think governs. A clause quoted correctly from a superseded 2021 agreement is a wrong answer with a right citation.

3. Read the sentence before and after. Contract clauses are riddled with conditions and cross-references. "Either party may terminate on 30 days' notice" reads very differently when the preceding sentence begins "After the initial 24-month term…". Widen the window by one sentence in each direction, always.

4. Ask the inverse question. If the AI says there is no non-compete, ask: "Quote any provision restricting either party from working with competitors, or state that none exists." Asking from the other direction catches retrieval misses — cases where the clause exists but was not surfaced by your original phrasing.

That fourth check deserves emphasis, because it is where grounded tools and chatbots diverge most sharply. The dangerous failure mode in legal work is not a hallucinated clause you can spot; it is a missing one you never think to look for. A tool that answers "these documents do not appear to address this" is giving you real information. A tool that manufactures a reasonable-sounding provision is actively harmful. FileAI is built to say when an agreement is silent rather than fill the gap, and you should still run the inverse question on anything that matters.

Step 4: Compare across the whole folder

Single-contract review is the easy case. The compounding value shows up when you point the same question at every agreement you have.

Across all agreements in this folder: list each counterparty, the liability cap, and whether the cap has carve-outs. Note any agreement where the cap is missing entirely.

Which of these contracts auto-renew in the next 120 days, and what is the notice deadline for each?

Where do the NDA and the MSA disagree on the definition of Confidential Information?

That last pattern — deliberately hunting for conflicts between documents — is the one that finds real problems. Two documents that each look fine in isolation can contradict each other on confidentiality duration, governing law, or who owns work product. Asking a per-document question never surfaces it; asking across the set does. FileAI retrieves across every selected file at once and tells you which file each answer came from, which is what makes the comparison auditable instead of merely plausible.

Output it as a table when you are building a summary for someone else:

Produce a table with one row per agreement: counterparty, effective date, term end, notice period, auto-renew (Y/N), liability cap. Cite the section for each cell.

Then spot-check the cells that would change a decision. You do not need to verify all forty cells; you need to verify the six that someone will act on.

Step 5: Choose how hard the model should think

Not every question deserves the same effort. FileAI splits this explicitly into two modes, and the choice matters for accuracy as much as speed.

Fast mode streams an answer in seconds and is right for lookups: what is the notice period, who are the parties, what is the governing law. Anything where the answer lives in one place in one document.

Deep mode reasons carefully across master agreements, exhibits, and amendments, and keeps working even if you close the tab. Use it when the answer requires assembling several passages: reconciling an amendment chain, comparing terms across a folder, or working out the actual effective obligation when three documents each say something partial.

The practical rule: if you could answer the question by finding one clause, use Fast. If answering it requires holding several clauses in your head at once, use Deep. Fast answers typically cost around 10 AI units and Deep answers around 50, so the trade is real but small — see pricing for how that maps to plans.

What AI contract analysis is genuinely bad at

Being honest about the limits is what makes the rest usable.

It is not legal advice. It finds and quotes what your documents say. Whether a clause is enforceable, market-standard, or wise for your situation is a judgment call for a lawyer. Use this to arrive at the lawyer conversation with the right clauses already pulled, not to skip it.

Scanned documents without a text layer. If a PDF is a photograph of a page, there is nothing to retrieve until it has been OCR'd. Check your inventory output in Step 1 — an agreement that returns nothing is usually a scan, not a mystery.

Handwritten amendments and margin notes. Signed-and-initialed changes scrawled on a printed page are exactly the kind of thing that governs and exactly the kind of thing that does not index well. Eyeball the signature pages yourself.

Arithmetic across many documents. Models are unreliable at multi-step numeric reasoning. If you ask for total contract value across twelve agreements, treat the number as a draft and check the components.

Defined terms that shift between documents. "Confidential Information" defined one way in the NDA and another in the MSA is a classic trap. Ask specifically which definition governs, and read both.

Anything where "probably" is not good enough. If a wrong answer means a missed renewal deadline or an uncapped indemnity, verify the clause yourself. The tool's job is to get you to the right page in seconds, not to make the call.

A repeatable 30-minute review

Put together, here is the workflow:

1. Assemble every file that forms the agreement into one folder — master, order forms, exhibits, amendments, NDA.
2. Inventory the folder and confirm parties, dates, and document types parsed correctly.
3. Ask the standard set — term, termination, auto-renewal, liability and carve-outs, indemnity, payment, confidentiality, assignment.
4. Verify each answer that matters: open the citation, check the file, read one sentence either side, ask the inverse question.
5. Compare across the folder for conflicts, outliers, and missing clauses.
6. Escalate the two or three genuinely ambiguous points to a lawyer, with the clauses already pulled and cited.

Thirty minutes gets you a cited map of a contract set that used to take an afternoon of reading — and, crucially, one where every line can be traced back to a specific sentence in a specific file.

Can you even upload this contract?

For most people reading this, the contract is confidential by its own terms, which makes "where does this file go?" the first real question, often before accuracy.

Four things are worth checking of any tool before you upload a signed agreement. Is storage private and encrypted, rather than a public bucket? Are your files used to train models by default? Does deleting a document actually delete it, including copies held by any model provider? And is there a clear retention story you could show your own security team?

With FileAI, agreements live in private, encrypted storage, are never served from a public folder, and are not used to train models unless you explicitly opt in — and deleting a document removes the provider copies too. The full detail is on the privacy and retention page. Whatever tool you choose, get concrete answers to those four questions first; "we take security seriously" is not one.

Under the hood, if you are curious

If you build software as well as read contracts, the mechanics here are not mysterious: documents get chunked and embedded, a query retrieves the nearest passages by vector similarity, and the model is constrained to answer from those passages with references back to them. Two of our engineering posts walk through the pieces with real code — RAG in Elixir: semantic search with pgvector and Postgres covers the retrieval half, and Elixir PDF AI extraction covers getting clean text and structured fields out of a PDF in the first place.

The takeaway for a non-engineer is simply this: citations are not a UI nicety bolted on at the end. They are a consequence of building the system so the model can only answer from retrieved passages. Tools that generate first and cite afterwards give you footnotes. Tools that retrieve first and generate from what they found give you evidence.

Summary

AI contract analysis works when you treat it as accelerated retrieval rather than delegated judgment. Load the complete agreement set, inventory it, ask specific questions that demand a source, verify every answer that matters by opening the citation and asking the inverse question, then compare across the folder to find the conflicts no single-document review would catch. Send the genuinely hard calls to a lawyer with the clauses already in hand.

The workflow only holds together if the tool can show you its work. If you want to try it on an agreement you actually care about, start free with one document — no card required — or see how it works end to end for contract analysis.