The two halves of contract intelligence
Document Insights
Clause Review
Before you start
Confirm the modules are on
Confirm your permissions
Have a few real contracts loaded
Step 1: Get contract documents in
Clause review runs against a contract record and the documents linked to it.- Upload the agreement from Actions → Upload Documents on the contracts list, from the contract’s Documents tab, or from the vendor’s Documents tab.
- Confirm the document type. Types like Master Service Agreement, Order Form, Statement of Work, NDA, DPA, Terms of Service, SLA, Software License Agreement, Contract Amendment, and Contract Addendum are what mark a document as contract paper. Type inference is good but not infallible on unusual formats, and scope decisions downstream key off the type.
- Link every document that makes up the agreement to the same contract record: the MSA, the order form, the DPA, the security addendum, the amendments. Guardian analyzes the set, not the file.

A contract record: the facts read from its documents, what needs attention, the AI summary, and the terms.
Step 2: Build your clause set
A clause set is your playbook: a named collection of reference clauses, each with the language tiers you are willing to accept. You can have several: a standard SaaS set, a stricter set for vendors touching regulated data, a professional-services set. Go to Configuration → Clause Sets. There are three ways to start, and most teams use the first two together.Start from the clause set library
The clause set library
Generate a clause set from your own paper
If you have a standard template (your MSA, your DPA, your preferred terms), Guardian can turn it into a clause set.Upload the baseline
Review what it extracted
Add your fallback tiers
Activate it
Baseline contract extraction reference
Import a clause set from a spreadsheet
If your standards already live in a spreadsheet, put them in the Coverbase template and upload the file instead of retyping them. One workbook can carry several clause sets, each with full multi-tier variant language. On the Clause Sets page open Add Clause Set, choose Download Import Template, fill in the Clauses sheet (one row per clause, with rows sharing a Clause Set value grouped into one set), then come back and choose Import from Spreadsheet. Preview import checks every row before anything is saved and lists any that will not import by spreadsheet row number, and one bad row never blocks the rest. Clauses whose identifier is already in the target set are skipped rather than overwritten, so a stale re-upload cannot replace negotiated language.Spreadsheet import and export reference
Build one by hand
Open Add Clause Set, choose Create Clause Set, name it, then add reference clauses one at a time with Add Clause. This suits a narrow, high-stakes set (an AI addendum standard, say), and rarely a full playbook.Step 3: Understand a reference clause
Every reference clause is one standard you hold vendors to.Writing guidance the matcher can use
Guidance is the instruction the model reads when hunting for vendor language. The library clauses are worth copying as a format. This is the shape that works, from the packaged Limitation of Liability clause:Step 4: Write your risk-tier variants
This is the step that determines whether Contract Guardian is useful or noisy. A variant is one version of the clause language at one level of acceptability, on a scale of 1 to 5. Coverbase matches the vendor’s actual language to the closest variant, and the tier of that variant becomes the verdict:- Low-confidence matches never auto-pass. If the matcher is not confident enough in the match, the clause is set to Needs review regardless of which variant it landed on.
- Language found outside its scope is escalated. If a clause turns up in a component it was not scoped to, or if the language materially conflicts with the matched variant, the clause goes to Needs review rather than being scored.
How many tiers do you need?
You do not need all five on every clause. Start with three and add as you learn:Tier 1: your ask
Tier 3: your fallback
Tier 5: your walkaway
Label your variants like a negotiator
The label shows up next to the verdict, so make it say what the tier is. From the library set:- Tier 1: “Vendor-favorable: 1x fees, 12 month lookback, broad consequential carve-out”
- Tier 3: “Balanced: 2x fees with carve-outs for confidentiality and data breach”
- Tier 5: “Unacceptable: liability disclaimed in full”
Step 5: Scope clauses to contract components
Guardian first detects the components inside your linked documents (the MSA, the DPA, the order form, the SLA, the NDA, the amendment, the SCCs, the AI addendum, and so on), then evaluates each reference clause only where it belongs. Set Applicable component types on each reference clause accordingly. A data-processing standard belongs on the DPA and MSA. A pricing standard belongs on the order form. Governing law belongs everywhere, so leave it unscoped. Scope decides what a missing clause means:Step 6: Run a review
A review runs in five steps, shown in the rail at the top of the page. You move through them in order, and the rail says where you are.
The five steps of a review. The rail marks the steps behind you as done.
Select documents

Step 1. Pick the standards to check against and the documents to read.
Analyze the contract
Coverbase extracts the text, detects components, and matches every reference clause across the documents you selected. If the vendor has a completed assessment, it then layers that evidence onto each flagged clause. A progress indicator runs while it works. You can navigate away and come back.Start another review
One review runs at a time, but a finished review does not lock the contract. Start a new review sits in the header on every step after the analysis. Use it when a run read the wrong documents, when you picked the wrong standard, or when new paper has landed since the last run. Starting a new review takes you back to step 1 with the pickers open. Previous runs stay readable.Step 7: Work the results
The last three steps of the rail are yours: read the results, decide each clause, then send what you decided.Review results

The Review results step. Four cards sort what the run found, and the table lists every clause it read.

A clause review on the Review tab. Vendor language scored against your acceptable, fallback, and unacceptable tiers, by severity.
What each row tells you
Each row shows the clause’s state and, when the vendor has a completed assessment, the suggested disposition. Click a row to open the clause in the review console, where the clause card carries the rest:Assessment insights
When the vendor has a completed assessment, Guardian cross-references the clause against that evidence and suggests a disposition: No action, Revise language, Add clause, or Escalate, with citations back into the assessment. A weak audit-rights clause matters more when the vendor’s assessment already shows control gaps, and less when they hold a clean SOC 2. The suggestion is input for your judgment rather than a verdict, and it sits separately from the clause state.Triage every flag
Triaging is the review. Marking a clause removes it from the flagged list while leaving the system’s verdict visible, so the record shows both what the AI concluded and what you decided.No action
Accepted risk
False positive
Create finding
Decide
The fourth step, labeled Summary on the rail, gives you one clause at a time in a three-pane console.
The decide console. Playbook positions on the left, the redline and your decision in the middle, the source document and clause facts on the right.
Communicate

The Communicate step. A follow-up draft built from the flagged clauses, with the Word export beside it.
- Copy to clipboard copies the draft for your own email.
- Send email opens the Coverbase email composer with the draft in it. It is addressed to the vendor’s contacts, copies the contract’s owners and watchers and the vendor’s owners, analysts and watchers, and attaches the redlined Word file when the review has one. Check it and send it from there.
- Create Finding from selected escalates the ticked clauses to a finding, when findings are on for your organization.
Download the redlined Word file
If the review read a Word document, choose Download redlined Word file next to the draft. You get the contract’s own.docx back with:
- The contract’s wording struck through and your playbook’s wording inserted, as tracked changes
- One comment per clause carrying the clause name, the reasoning, and the language you are asking for
When nothing was flagged

A run that flagged nothing offers a new review instead of an empty draft.
Step 8: Iterate
Your first review is a draft of your playbook, not a verdict on the vendor.Too many flags
Too many flags
Clauses come back Missing that are plainly in the contract
Clauses come back Missing that are plainly in the contract
Everything lands on Needs review with low confidence
Everything lands on Needs review with low confidence
Rerun after you change something
Rerun after you change something
Reference clauses are versioned
Reference clauses are versioned
Run Contract Guardian from MCP or the API
You can build clause sets, run reviews and work the results from an MCP client or with an API key, as well as in the dashboard. An MCP client reads withquery_engagements_contracts(kind="clause_sets"), query_engagements_contracts(kind="clause_review") and query_engagements_contracts(kind="clause_review_redline"). It writes with mutate(entity="clause_set", action="save"), mutate(entity="reference_clause", action="save"), mutate(entity="clause_review", action="start"), mutate(entity="clause_match", action=...) and mutate(entity="clause_follow_up_draft", action="request").
The API routes are /v1/clause-sets, POST /v1/contract-records/{contract_id}/clause-reviews, /v1/clause-matches and the redline download. See Clause sets and Clause reviews.
Before an MCP client sends a write, it shows you the change and waits for you to confirm it. The MCP tool reference lists every field.
An API key cannot accept a clause risk, archive a clause set or delete a reference clause. A signed-in user decides those.
A workable rollout
Week 1: copy and calibrate
Week 2: tune the noisy clauses
Week 3: add your own paper
Week 4: put it in the workflow