Skip to main content
For AI agents: a documentation index is available at https://docs.coverbase.com/llms.txt. This page is also available in markdown by appending .md to the URL.
This page is part of the User Guides collection and goes with the Contract Guardian guide, which covers clause sets end to end. Read this one when your standard is a document rather than a spreadsheet.
Most companies already have their standard written down as a contract: the MSA you send first, the DPA your privacy team maintains, the security addendum you attach to anything touching customer data. Import from Document reads one of those and turns it into a clause set, so your playbook starts from language you already use rather than a blank page. The same entry reads a clause library or negotiation playbook; see Importing a clause library or playbook.
This is one of four ways to build a clause set. The others are copying the packaged library, importing a spreadsheet, and adding clauses by hand. They mix freely: generate from your paper, then paste in the two clauses your template forgot.

​
Which import do I want?

The two upload paths solve different problems.

Import from Document

You have a contract. Coverbase reads the document and proposes the clauses, with the exact source text quoted. Fastest way from “we have a template” to a working set, but every clause arrives with one tier, so you finish the tiering by hand.

Import from Spreadsheet

You have a playbook. Your standards already exist as structured rows, probably with fallback positions. You get exactly what you typed, including full multi-tier variant language, and nothing is inferred.
A common sequence: generate from your paper to get the clause inventory, then hand-write the fallback tiers in the UI. If your team already maintains a negotiation matrix, skip extraction and import the spreadsheet.

​
Run an extraction

1

Upload the baseline

On Configuration → Clause Sets, open Add Clause Set and choose Import from Document. Drop in your template as a PDF, DOCX, DOC, TXT, or MD file.Set Document type to Baseline contract (one agreement), or leave it on Detect automatically. Give the set a Name, and optionally a description, then choose Import.Use a clean template, not an executed agreement. A signed contract carries one counterparty’s negotiated edits, and you would be baking their redlines into your standard.
2

Wait for processing

Extraction runs in the background; you can leave the page and come back. The clause set appears immediately with a processing indicator and fills in as the run completes.
3

Review what it extracted

Each proposed clause arrives with a name, category, severity, applicable component types, and the exact source text it came from, with a page citation you can check against your document.
4

Add your fallback tiers

This is the step people skip, and the set is not usable without it. See What you have to finish below.
5

Activate it

Generated clause sets are created inactive, so a half-finished playbook cannot be run against a live contract: an inactive set is not offered when you start a review, and it carries an Inactive badge on the Clause Sets page. Once the tiers are in, open the set, click the actions menu beside Add Clause and choose Activate. Deactivate in the same menu takes it back out of use; reviews that already used it keep their results, but they cannot start a new round until you activate it again.

​
What you get back

Each extracted clause is a normal reference clause, so you can edit, retier, or archive any of it.
Language it cannot quote verbatim is dropped, not paraphrased. Every extracted clause and every piece of source evidence is checked back against the text of the document it cites; anything that does not appear there contiguously is discarded. You may get fewer clauses than you expected, but what you get is your own paper, not a model’s summary of it.

​
What you have to finish

A single Tier 1 variant is a floor, not a playbook. It marks anything that is not your exact template language as needing review, which on a real vendor’s paper is almost everything. A set run in that state flags nearly every clause.
Before you point a generated set at a live contract:
  1. Add the tiers you would accept. For each clause that matters, write the Tier 2 (“acceptable”) and Tier 3 (“fallback”) language your legal team would sign without escalating.
  2. Fill in the Guidance field. Extraction may propose a short comparison note, but not the aliases and extraction signals that help the matcher find a clause under a different heading. The Contract Guardian guide shows the four-section format.
  3. Retune severities. Reserve Critical for clauses that would block a signature.
  4. Archive what you do not care about. A template contains boilerplate you have no opinion on. Every clause you keep is a clause every review has to triage.
  5. Activate it from the set’s actions menu, then test it against a contract you already know before you rely on it.

​
Importing a clause library or playbook

Some teams keep their standard as a clause library or negotiation playbook rather than a contract: numbered clauses, each with a preferred position, a fallback, and sometimes a line the team will not cross. Import from Document reads that layout as it is written instead of guessing at it. Choose Clause library / playbook (positions per clause) under Document type, or leave Detect automatically on. The positions are copied verbatim, never rewritten. Severity is set from the document’s own rules and the clause’s subject: Critical for a clause on the document’s “no fallback” list or one whose deviations need executive approval, High for one with a floor or a subject such as data, security, or indemnity, Low for administrative terms such as notices and governing law, and Medium otherwise. Check them as you would any proposed severity. When the run finishes, the clause set says how many of the document’s clauses it imported. Anything the reader could not place, such as a clause with no preferred position or text outside any labeled block, is listed above the clauses under items need review. Open those clauses and confirm or fix them. An imported playbook is created inactive like any other generated set. Under the default scoring, a vendor whose language matches your fallback reads as Needs review.

​
Run an extraction from MCP or the API

You can start an extraction and follow it from an MCP client or with an API key, as well as in the dashboard. An MCP client starts one with mutate(entity="clause_set", action="extract_from_documents") and reads its progress with query_engagements_contracts(kind="baseline_extraction"). The API routes are POST /v1/clause-set-baseline-extractions and GET /v1/clause-set-baseline-extractions/{run_id}. See Build a clause set from documents. To finish the set, edit its reference clauses with mutate(entity="reference_clause", action="save") or the /v1/clause-sets/{clause_set_id}/reference-clauses routes. 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 archive a clause set or delete a reference clause. A signed-in user does that.

​
Troubleshooting

Contract Guardian guide

Clause sets end to end: the reference clause anatomy, writing risk-tier variants, and running a review.

The clause set library

The 12 packaged clause standards you can copy instead of, or alongside, extracting your own.

Import and export clause sets as spreadsheets

Bring a playbook in from a workbook when your standards already live in structured rows.