Your data. Their contract. Nothing invented.
Conovo turns the agreement your users already send into an output of the record your product already stores — generated, validated, and executed inside your app, under your brand. Every value comes from your data or from code. None of it comes from a model.
npm i @conovo/react @conovo/node- No model call produces a value in a sent contract
- DOCX in, DOCX out — clause numbering and formatting intact
- Every send reproducible from its pinned version, forever
{ org: { name: "Meridian Partners" },
client: { fullName: "Sarah Chen" },
deal: { startDate: "2026-03-04", total: 1450000 } }1.1This Agreement is entered into as of March 4, 2026 by and between Meridian Partners (“Provider”) and Sarah Chen (“Client”).
2.1The total fee shall be $14,500.00, payable in three installments of $4,833.33.
Three parties. You only build for one.
Conovo is the only layer that understands your users have customers of their own. That shape is why a contract-lifecycle tool doesn’t fit here and a signature API doesn’t reach far enough.
The platform
Install two packages and mint a session from your server. You hold the customer relationship, set the pricing, and own the experience end to end.
integrates onceThe businesses inside it
They bring the agreement they already use, confirm what varies, and generate it from records they already keep. They never open a second tool.
never leaves your productThe counterparty
They receive a finished agreement in your user’s name and execute it. No account, no portal, no third-party branding anywhere in the flow.
never hears our nameimport { Conovo } from '@conovo/node' const conovo = new Conovo({ secretKey: process.env.CONOVO_SECRET_KEY }) export async function POST() { const org = await currentOrg() // however you resolve the signed-in business const session = await conovo.sessions.create({ workspace: { externalRef: org.id, name: org.name }, }) // { token, expiresAt } — 15 minutes, scoped to that one business return Response.json(session) }
That is the whole server integration. Your secret key never reaches the browser, and scope comes from the token rather than the request — so a session minted for one business cannot read another’s templates whatever the client sends. Read the full guide →
- Wealth & investment
- Advisory agreements and subscription documents
- Construction
- Subcontractor agreements and change orders
- Staffing
- Placement agreements and contractor terms
- Professional services
- Engagement letters and statements of work
- Insurance
- Producer and broker agreements
- Logistics
- Carrier agreements and rate confirmations
The gap
Every vertical platform hits this at the same point in its roadmap.
Contracts are the feature your roadmap keeps postponing.
Your users run their business inside your product — until it’s time to paper the deal. Then they export to Word, retype the counterparty and the amount you already store, email a PDF, and chase a signature in a thread you can’t see. The most valuable moment in their workflow happens somewhere else.
Building it properly means document parsing, a field model, an expression engine that can’t round money wrong, versioning, an audit trail, and a signature integration. That’s two quarters of work that isn’t your product.
How it works
Setup happens once per template. Everything after it is deterministic.
Bring the contract they already use.
No template authoring, no clause library to populate, no migration. Conovo starts from the document your user has been sending for years.
Upload the document
Your user drops in the DOCX they already send — an advisory agreement, a subcontract, an engagement letter. Conovo parses the real structure and keeps it intact.
On PDFs, plainly: a PDF can be uploaded to set a template up and see the fields Conovo finds, but generation fills DOCX only — that’s what keeps clause numbering and formatting exact. Generating from a PDF-sourced template is refused rather than quietly producing something unreliable.
<ContractStudio />AI proposes, your user confirms
Fields, formulas, signing parties, repeating tables, and sections that don’t always apply are detected and highlighted in the document itself. Nothing is converted silently — every proposal is accepted or edited by a human before it becomes part of the template.
confidence-scored · human-confirmedBind fields to your data
Register your payload schema once and Conovo proposes the mapping — client.fullName into the counterparty, deal.total into the amount. Whatever your platform calls that record — a deal, a job, a case, a matter, a policy — you hand it over and bindings resolve against it.
platform_bound · workspace_default · per_deal · computedResolve, validate, execute
One click resolves every field, runs the validation gate, produces the finished document, and sends it for execution. Anything that fails validation becomes a draft for review — never a contract that goes out wrong.
<SendContract /> · <BulkSend /> · <ContractInbox />Guarantees
Architectural commitments, not settings someone can turn off.
No model output ever lands in a contract.
A language model is the right tool for reading a document once. It is the wrong tool for deciding what a counterparty owes. Conovo draws that line in the architecture rather than in a policy doc — including at the one place a model still runs on the send path, which is the second guarantee below.
The send path is deterministic
No model call can produce a value that lands in a generated contract. AI discovers the rules once, at setup, with a human confirming every proposal. Send-time resolution, arithmetic, and formatting are pure code, so the same inputs always produce the same document.
The one send-time model call is read-only
On unattended sends — the path with no human in it — an optional anomaly check reads the finished contract and flags placeholder names, absurd amounts, or dates in the past. It can hold that contract back as a draft. It has no write path to the document, and if it fails or times out the deterministic validator is still the gate.
No model does arithmetic
Money and dates run through a decimal-safe expression evaluator. Formulas are stored as data and evaluated by code, so an amount is never a plausible-looking guess.
Validation gates every send
An empty required field, inconsistent math, or a cross-field contradiction holds the contract as a draft for review. Silent failure becomes a draft — never a dispatch.
Signed contracts are reproducible forever
Templates are versioned and every contract pins the version it was generated from, alongside the exact resolved values used. You can rebuild a two-year-old agreement byte for byte.
Tenancy is enforced in one layer
Workspace scope comes from the session token, never from the request. Every query passes through a single enforced boundary — one business can never read another’s templates.
Audit everything, log nothing sensitive
Every mutation writes an event. Contract content, resolved values, and recipient details never appear in logs — including ours.
Where it fits
A component of your product, not a destination for your users.
Not a CLM. Not a signature API.
Contract lifecycle platforms sell to the legal team at the company signing the contract — they compete with you for your user. Signature APIs put a pen on a PDF you still have to build and fill yourself. Conovo is the layer in between.
| CLM platform | Signature API | Conovo | |
|---|---|---|---|
| Who buys it | Your customer’s legal team | You | You |
| Who your user sees | A second product to log into | Your app, then a signing page | Only your app |
| Starting point | Author templates in their editor | You supply a finished PDF | The document they already send |
| Field discovery | Manual tagging | Manual coordinates | AI-proposed, human-confirmed |
| Fills from your data | Via integration project | You build the merge | Bound to your payload schema |
| Money & date math | Manual entry | Your code | Decimal-safe expression engine |
| Who you bill | Nobody — your user pays them | You pay per envelope | You, metered per contract sent |
Execution
What your security review will ask about on the first call.
Signing is the last step — but it’s a real one.
Saying execution isn’t the product is a statement about where the hard work is, not an admission that we punted on it. Multi-party ordering, status webhooks, and the audit trail behind them are built and running.
A real provider, behind an interface
Documenso executes today. Conovo hands it the finished PDF, orders signers by the signing parties confirmed on the template, and consumes signature-verified webhooks for opened, signed, completed, and declined. The provider is swappable without touching your integration — you never wrote against it.
Every state change is an event
Each mutation and each signature transition writes an immutable event row. A contract pins the template version it came from and the exact resolved values used, so the record of what was sent, when, and to whom survives long after the deal does.
Your users’ documents stay out of logs
Contract content, resolved field values, and recipient details never reach a log line — ours included. Documents live in object storage; the audit trail records that something happened, never what it said.
One AI vendor, one moment
The uploaded document goes to Anthropic’s API at template setup, to propose fields and formulas a human then confirms. Nothing goes to a model at send time except the read-only anomaly check on unattended sends. That is the entire AI surface, and it is the same answer we give under NDA.
Depth
Scale, durability, and the limits on automation.
You don’t configure any of this.
The four steps above are the whole integration. Everything below is already running the first time one of your users sends four hundred contracts instead of one.
A spreadsheet becomes a batch
Upload a CSV, confirm the proposed column mapping, and review a pre-flight table showing typed values, plain-English issues, and statistical outliers before anything sends. Duplicates against an active contract are skipped, not resent.
Pause, resume, and never double-send
Each item is a durable step. A provider outage pauses the batch with the queue intact; resuming re-drives only what hasn’t gone. Contracts are linked before dispatch, so a retry can never generate twice.
Automation earns its way in
Auto-send stays locked until a template has been reviewed and sent enough times to prove itself. Any validation flag on an unattended send demotes it to a draft with a loud audit event.
A second net on unattended sends
The read-only check from § 3 in practice: placeholder names, absurd amounts, and past dates hold the contract as a draft for a human. It never edits, and it never overrides the validator that already ran.
Questions
What platform teams ask before the first call.
Common questions.
What is Conovo?
Conovo is contract generation infrastructure that vertical SaaS platforms embed in their own products. It lets a platform give its business users contract generation and e-signature without building a document pipeline: the user uploads the agreement they already send, AI identifies the variable fields, those fields bind to data the platform already stores, and the finished contract is generated, validated, and sent for execution under the platform's own brand.
How is Conovo different from DocuSign or PandaDoc?
Signature APIs collect signatures on a document you have already produced. Conovo produces the document. It parses the contract a business already uses, maps its variable fields onto the host platform's data model, evaluates formulas in decimal-safe code, validates the result, and only then sends it for execution. Signing is the last step of the pipeline rather than the product, and the signing provider sits behind an interface.
Is Conovo a contract lifecycle management (CLM) platform?
No. CLM platforms such as Ironclad, Juro, or SpotDraft are sold to the legal team at the company signing the contract, and the user logs into them directly. Conovo is sold to a software platform and embedded inside it, so the businesses using it never leave the product they are already in and never see Conovo's brand.
Who is Conovo for?
Vertical SaaS platforms whose users send contracts to their own customers — wealth and investment platforms, construction and contractor software, staffing and recruiting systems, professional services tools, insurance platforms, and logistics software. The common pattern is that the platform already stores the parties, amounts, and dates that the contract needs.
Does an AI model write the contract?
No. No model output ever lands in a generated contract. AI is used at setup to propose which parts of a document vary and how they map to platform data, and a human confirms every proposal before it is saved. At send time, resolution, money and date arithmetic, and formatting are deterministic code, so the same inputs always produce the same document. There is exactly one model call on the send path — an optional anomaly check on unattended sends — and it is read-only: it can hold a contract back as a draft for review, and it has no path to alter a word of the document.
Who actually collects the signature, and is it a real execution path?
Signing runs through a real e-signature provider behind a swappable interface; Documenso is the provider today. Conovo sends the finished PDF, orders the signers according to the signing parties confirmed on the template, and receives signature-verified status webhooks for opened, signed, completed, and declined. Every transition is written to the audit trail, and the same contract can be reproduced later from its pinned template version and stored resolved values.
Do our users or their customers see Conovo branding?
No. Conovo ships as React components and a Node SDK that render inside the host platform's product under its own styling. The businesses using it and the customers who sign the contracts never encounter Conovo's name, an account, or a separate portal.
What document formats does Conovo support?
DOCX is the format for generation, because filling it preserves the real document structure — paragraphs, tables, and clause numbering — so the produced contract keeps the original formatting exactly. A PDF can be uploaded to set a template up and review the fields Conovo finds, but generating from a PDF-sourced template is refused rather than producing an unreliable result. Platforms whose users only hold PDFs should plan on a one-time conversion to DOCX.
How is Conovo priced?
Conovo bills the platform, not the platform's users. Pricing is a platform subscription plus a meter on contracts sent — there is no per-seat charge on your businesses and no fee per template or per template author, so onboarding a user who sends two contracts a year costs you nothing until they send them. The sandbox generates real documents against test data without a card.
Get started
Put contracts where the work already happens.
Create an account, register your payload schema, and mint your first session token. The sandbox generates real documents against test data — no card, no call.
Priced as a platform subscription plus a meter on contracts sent — never per seat, never per template. See the tiers →