Legal & Compliance

EveryNDA,vendorMSA,andsupplieraddendumtriagedbeforeithitsanattorney'squeue.

First-pass review before the queue: an orchestrator walks every contract page by page, a vision sub-agent isolates each clause with tight bounding boxes, and a per-clause pass rates it against the team's playbook — green, yellow, orange, red — with a plain-English explanation and a redline ask. The reviewing attorney opens the document already triaged: severity counts, key concerns linked to section numbers, and a single-line bottom line about whether the paper is signable as drafted.

Key Takeaways

Throughput at department scale

Hundreds of contracts a week move through first-pass review without adding headcount. NDAs, vendor MSAs, supplier addenda, DPAs, statements of work — same pipeline, same rubric, same triage output.

Consistency across reviewers

Every contract is read against the same playbook. A junior reviewer's first-pass triage matches the GC's first-pass triage. Disagreement happens at the second pass, where it should.

Playbook-aware, not generic

The team's positions — caps, indemnity carve-outs, governing-law preferences, IP rules, data-protection floors — are passed in as deal context. Clauses are rated against the team's bar, not a one-size-fits-all baseline.

Section-anchored asks

Every flagged clause carries its section number, page number, and a one-line redline ask the attorney can paste into the negotiation thread or hand to the business owner. Nothing is abstract.

Triage before the document opens

The reviewing attorney sees severity counts and the bottom line in a notification. Standard paper closes in minutes; only the unusual ones get billable attention.

Counterparty paper stays in your tenant

The pipeline runs in the team's environment, against the team's CLM, with the team's playbook. Counterparty paper never leaves the tenant. The orchestration is the only thing the model sees.

First-pass review is where the hour goes. Most of what gets read is already standard.

An in-house legal team spends most of its week on third-party paper. Vendor MSAs, supplier addenda, NDAs from prospects, DPAs from processors, redlines on a renewal. The volume is real; the variance inside the volume is small. Most clauses across most contracts are standard, and the reviewing attorney already knows what they will say. The bottleneck is not judgment. The bottleneck is reading enough of the document to confirm it is, in fact, standard.

The automation runs that confirmation pass at department scale. An orchestrator opens the contract, walks each page, and asks a vision sub-agent to identify every distinct clause and return its location. A second pass takes each clause individually and rates it against the team's playbook — caps, carve-outs, governing law, indemnity floors, IP rules. The reviewing attorney sees a triaged document: severity counts at the top, clause cards on the right, and the original PDF rendered on the left with low-opacity green, yellow, orange, and red overlays on every clause. Standard paper signs faster. Unusual paper gets the senior attention it actually needs.

The four colors are the rubric, and the rubric is the team's IP. Green is standard and benign — boilerplate severability or governing-law text. Yellow is standard but worth confirming — auto-renewal, arbitration, a thirty-day notice window. Orange is unusual or one-sided in a way that's worth flagging. Red is a real problem against the team's playbook: a fee-shifting clause the team doesn't accept, an IP grab over pre-existing work, a forum-selection clause the team can't realistically defend in. The default posture is 'this is normal' — the system flags only what genuinely deserves flagging, then explains why with reference to the playbook.

The proof of concept is public. Trampoline runs the same pipeline at amigettingfucked.ai — anyone, including a member of the team, can drop a single PDF and see the output in minutes. Production deployments wire the same pipeline into the team's CLM, route triaged reviews to the right attorney's queue, and run against the team's playbook instead of a generic one.

One signature, the team's playbook in deal context

The entire pipeline — page rasterization, clause detection, per-clause rating, triage synthesis — runs through a single Predict-RLM signature. The team's playbook (caps, carve-outs, governing-law preferences, IP rules) flows in as deal context, so every rating is against the team's bar, not a generic baseline. The orchestrator decides parallelism per page and per clause; the rubric and JSON schema live in a Skill object passed alongside.

python

import dspy
from predict_rlm import File, PredictRLM, Skill

class ReviewContract(dspy.Signature):
    """Identify every meaningful clause in the contract pages and rate it
    against the team's playbook. Return strict JSON in result_json."""
    pages: list[File] = dspy.InputField(
        desc="page images in order; auto-mounted at /sandbox/input/pages/"
    )
    deal_context: str = dspy.InputField(
        desc="JSON: {dealType, counterparty, role, playbook, concerns}"
    )
    result_json: str = dspy.OutputField(
        desc="strict JSON: {synthesis, clauses: [...]}; no markdown fences"
    )

agent = PredictRLM(
    ReviewContract,
    lm="anthropic/claude-opus-4-7",      # frontier model — orchestrator
    sub_lm="anthropic/claude-haiku-4-5", # vision model — per-page, per-clause
    skills=[contract_review_skill],      # severity rubric + bbox discipline
    max_iterations=40,
)

result = agent(
    pages=[File(path=p) for p in page_paths],
    deal_context=json.dumps({
        "dealType": "vendor-msa",
        "counterparty": "ACME Corp",
        "role": "customer",
        "playbook": {
            "liability_cap_min": "12x annual fees",
            "no_fee_shifting": True,
            "governing_law": ["Ontario", "Delaware"],
            "ip_assignment": "none over pre-existing work",
        },
        "concerns": "renewal terms, IP carve-outs in cap",
    }),
)
# result.result_json → { "synthesis": {...}, "clauses": [
#   {"section_number": "11.4", "severity": "red",
#    "title": "IP indemnity excepted from liability cap",
#    "playbook_violation": "liability_cap_min",
#    "regions": [{"page": 14, "bbox": [0.12, 0.34, 0.88, 0.41]}],
#    "what_it_means": "...", "recommendation": "..."}, ... ]}

Built on predict-rlm — open source. github.com/Trampoline-AI/predict-rlm

What lands in the reviewing attorney's queue

The reviewing attorney receives a triage row in their CLM (Ironclad, Agiloft, ContractPodAi) or as an Outlook task: severity counts, the bottom line in one sentence, and the headline asks pre-written. Opening the row brings up the two-pane review — the original PDF rendered on the left with low-opacity green, yellow, orange, and red overlays on every analyzed clause, and a clause-card column on the right with each clause translated into plain English, rated against the playbook, and accompanied by a paste-ready redline ask. Standard paper closes from the queue. Unusual paper opens with the senior attorney's attention already focused on the two clauses that matter. Trampoline runs the same pipeline as a public proof of concept at amigettingfucked.ai — the legal team can try it on a non-confidential PDF in minutes before scoping a production deployment.