Contract types and the global taxonomy

When you upload a document, Clment classifies it against the global contract-type taxonomy — a curated tree of categories (e.g. Technology, Software & Data) and finer types beneath them (e.g. Software License Agreement). The result shows on the contract as its type, and feeds organisation, filtering, and type-aware review context.

The taxonomy is a single shared asset across all of Clment — every region classifies against the same tree — and it extends itself automatically as the AI meets contracts that don’t fit an existing type.

How classification works

On upload, after the document text is extracted, an AI classifier assigns:

• a category — one of the stable top-level buckets below (C01–C17); and
• a contract type — the specific kind within that category (e.g. C03-01 Non-Disclosure Agreement (NDA)).

Classification is best-effort and confidence-aware — it won’t force a document into the wrong bucket. When nothing fits cleanly, one of three things happens:

• A contract with no matching type → it’s filed under the best-fit category and the classifier proposes a new type for it. The proposed type becomes official once it clears the guardrails (see How the taxonomy extends itself, below) — so “no existing type fits” grows the taxonomy rather than dumping the contract in a junk bucket.
• A non-contract document (tax form, invoice, certificate) → filed under Other (C16).
• Genuinely unidentifiable — too little readable text, very low confidence, or the classifier couldn’t run → Unclassified (C17). This is the rare exception, not the catch-all; you can re-run classification later as the taxonomy grows.

The categories

Categories are the fixed backbone of the taxonomy — there are 17, and they don’t change without a deliberate version bump. Beneath each sits the finer type list, which grows automatically as new kinds of contracts come through.

The list below is pulled live from the taxonomy, so it always reflects the current categories and every type beneath them — including the ones the classifier has added automatically. (If your browser blocks scripts, you’ll see a representative snapshot instead.)

C01–C15 are real contract categories. C16 (Other) collects documents that aren’t contracts at all — tax forms, invoices, certificates — so they’re labelled honestly rather than mis-filed as an agreement. C17 (Unclassified) is the rare fallback for a document the AI genuinely can’t identify (too little readable text, very low confidence, or the classifier couldn’t run); unlike every other category, it never expands. A contract that simply doesn’t match an existing type does not land here — it gets a new type proposed instead.

How the taxonomy extends itself

The taxonomy grows organically instead of being hand-maintained:

1. A gap is spotted. When the classifier meets a genuine contract that fits a category but matches none of its existing types, it proposes a new type under the closest category (C01–C16) — with a suggested name and a one-line rationale.
2. Guardrails vet the proposal. Before anything is added, the proposal passes content checks (sensible length, no junk or profanity) and de-duplication — a near-match to an existing type is folded into that type rather than creating a duplicate. Proposals can’t target Unclassified (C17).
3. It’s added once, everywhere. An accepted type is written to the single global taxonomy and pushed out to every region within a couple of minutes, so the next classification — in any region — can use it. Each AI-added type keeps an audit trail (what was added, when, and which document prompted it).

The practical effect: the more contracts flow through Clment, the more precise the type list becomes — without anyone having to predefine every possible contract type up front. The 17 categories stay stable; the detail beneath them keeps filling in.

Where you see it

• Each contract displays its classified type on the contract page and in the contracts list.
• You can filter the contracts list by category to narrow to, say, all your NDAs or all your leases.
• Reviews use the classified type as context, so a lease and a SaaS agreement are read with the right lens.

Classification is automatic — there’s nothing to configure. If a contract looks mis-classified, re-running its review or classification after the taxonomy has grown will often place it correctly.