build.allanninal.dev

Part 4 of 7 · Contract summarizer series ~5 min read

How risky clauses get flagged

The plain facts are pulled. Now the system has to find the few clauses that tend to bite — the auto-renewal with a tiny notice window, the late-fee that compounds, the liability cap that puts the whole company on the hook — and explain each in words an owner can act on. This is where the stronger Sonnet model earns its place. But it never reads the whole contract and it never tells you what to do. Four gates sit between a clause and a flag, and the last one decides whether the right next step is a lawyer.

Key takeaways

  • A clause search finds the paragraphs that match the always-flag list, so the model reads only a few.
  • Sonnet 4.6 — the stronger model — explains each flagged clause: what it says and why it matters.
  • Every flag quotes the exact clause. A flag with no quote is dropped, same rule as the term pull.
  • The model says what to look at, never what to do. It is not advice and the wording stays that way.
  • A high-stakes clause trips the last gate: the flag says “run this past a lawyer before signing.”

Four gates on every flag

Four gates between a clause and a flag on the summary A horizontal flow diagram. On the far left, a "Clauses + flag list" box: the numbered clauses for this contract plus the always-flag list from the rules doc — auto-renewal, penalties and late fees, liability and indemnity, personal guarantees, exclusivity, termination. Four gates sit in a row to the right, each drawn as a vertical bar. Gate 1: Clause search — each always-flag topic is turned into a Titan embedding and matched against the clause embeddings in the S3 Vectors index, returning the few clauses that actually match, so the model never reads the whole contract. Gate 2: Sonnet read — the stronger Sonnet 4.6 model reads each matched clause and writes a plain note: what it says, why it matters, in two or three short sentences, with the clause quoted. Gate 3: Quote check — every note must quote real text from the clause it claims to be about; a note that quotes nothing, or quotes text not in the clause, is dropped. Gate 4: Escalate check — each kept flag is scored against the rules-doc thresholds; a high-stakes clause (a personal guarantee, a liability cap above the contract value, an auto-renewal with a short notice window) gets a "call a lawyer" line added. After all four gates pass, the flags are written to the summary draft, each with the quoted clause and its plain note. A note at the bottom: the model says what to look at and why, never what to do — and the high-stakes ones say to call a lawyer. Clauses + flag list numbered text, topics to flag Gate 1 Clause search topic → Titan embedding match S3 Vectors return the few that match Gate 2 Sonnet read stronger model reads each plain note: what it says, why it matters Gate 3 Quote check note quotes real clause text? if not, drop the flag — no guesses Gate 4 Escalate check score vs rules thresholds high stakes → add “call a lawyer” line Flags written to the summary draft — each with the quoted clause and a plain note auto-renewal · penalties · liability · guarantees · the few that matter high-stakes flags carry a “run this past a lawyer before signing” note The model says what to look at and why — never what to do, and the high-stakes ones say call a lawyer.
Fig 4. Four gates between a clause and a flag. Search the clauses for the topics that matter. Read each with the stronger model. Check every note quotes real text. Score the stakes and, where they’re high, say to call a lawyer. Only flags that pass all four reach the summary.

The system doesn’t hand the whole contract to the stronger model — that would be slow and costly, and most clauses are boilerplate. Instead it searches. Each topic on the always-flag list (auto-renewal, penalties, liability, personal guarantees, exclusivity, termination) is turned into an embedding — a list of numbers that captures its meaning — using Amazon Titan Text Embeddings V2. Every clause from the intake is embedded the same way. A search in Amazon S3 Vectors, AWS’s built-in vector store, matches each topic to the clauses that mean the same thing, even when the contract uses different words (“evergreen term” instead of “auto-renewal,” “limitation of liability” instead of “liability cap”).

The result is a short list: the handful of clauses that actually concern the topics you care about. Those are the only clauses the stronger model reads. A forty-page contract might surface six or eight clauses worth a look; the rest never reach Gate 2.

Gate 2: the Sonnet read

Now the stronger model goes to work, but only on those few clauses. Bedrock Sonnet 4.6 reads each matched clause and writes a short plain-English note: what the clause says, and why it matters to you, in two or three sentences. For an auto-renewal clause: “This contract renews itself for another 24 months unless you cancel between 90 and 60 days before it ends. Miss that window and you’re locked in for two more years.” For a liability cap: “If something goes wrong, the most you could claim back from the vendor is one month’s fees — about $1,450 — no matter how big the actual loss.”

Sonnet is used here, and only here, because this is the reading that needs judgment. Spotting that a notice window is unusually short, or that a liability cap is low relative to what’s at stake, is exactly the kind of between-the-lines reading the cheap model can’t be trusted with. There are only a few clauses per contract, so the stronger model’s cost stays small — the math is in Part 6.

Gate 3: the quote check

Same rule as the term pull, applied to the flags: every note has to quote the exact text of the clause it’s about. After the Sonnet read, a plain Python check confirms the quoted text actually appears in that clause. If a note quotes nothing, or quotes words that aren’t in the clause, the whole flag is dropped — not shown with a warning, dropped. A flag you can’t trace back to the contract is worse than no flag, because it teaches the reader to doubt the ones that are real. The quote is what makes a flag checkable: the owner can read the clause for themselves, right there in the summary, and see the system isn’t making it up.

Gate 4: the escalate check

The last gate decides when a flag should send you to a lawyer. The rules doc holds the thresholds in plain prose: any personal guarantee at all, any liability cap above the contract’s value, any auto-renewal with a notice window shorter than 30 days, any clause that hands away exclusivity or your data. Each kept flag is scored against those thresholds. If it crosses one, the flag gets an extra line: “This is high-stakes — run it past a lawyer before you sign.”

This is the system knowing its own limits. It will happily tell you what an indemnity clause says and why it matters. It will not tell you whether to accept it, negotiate it, or walk away — that is legal advice, and the system doesn’t give legal advice. When the stakes are high enough that the answer really matters, it does the one responsible thing it can: it points you at a human who is allowed to answer. Part 5 makes that boundary — grounded, never advice, always a human in the loop — into the rule the whole summary lives by.

Next post: how the whole summary stays grounded in the actual text, the not-legal-advice banner, and the approval step before anything is filed or sent.

All posts