Stop prompting an assistant. Give it the file.

A copilot suggests. An agent finishes.

Most contract AI is a better autocomplete bolted to a document editor. The work it leaves behind is the work that actually takes the time.

• What a copilot gives you: A draft you still have to route, chase and reconcile
• What a copilot gives you: A summary of a thread you then act on manually
• What a copilot gives you: Suggested language you paste into the real document
• What a copilot gives you: Risk flags with no mandate behind them and no next step
• What a copilot gives you: A chat window that forgets the matter when you close it
• What a copilot gives you: Nothing to show an auditor about how a term was agreed
• What the assistant does: Drafts, negotiates and routes the agreement to signature
• What the assistant does: Acts on the thread directly — it is the brief, not an input
• What the assistant does: Edits the live instrument, writing a version per change
• What the assistant does: Works a mandate you authored, escalating only outside it
• What the assistant does: Holds the matter: obligations, dates and the next deadline
• What the assistant does: Leaves a tamper-evident record of every turn and tool call

The work it takes off your desk entirely

Each of these is a task the assistant completes, not a prompt it answers. You see the result and the record of how it got there.

• Intake and qualification — Reads the thread, extracts parties, terms and value, identifies what is unresolved, and opens the right room with the right document type.
• Drafting from precedent — Assembles the instrument from your templates and clause library, resolving variables from the conversation rather than leaving blanks.
• Review and risk triage — Diffs inbound paper against your standard, ranks deviations by exposure, and states the position your mandate calls for on each.
• Negotiation — Opens clause-level negotiations and works them turn by turn against a person or another agent, trading only inside your ladder.
• Approval routing — Sends the right decision to the right approver with a one-paragraph brief, then resumes the run the moment it is answered.
• Obligation tracking — Extracts term, renewal windows, notice periods and conditions from executed agreements so deadlines stop depending on memory.

Autonomy you can turn up one notch at a time

Nobody hands a contract portfolio to an agent on day one. Start in shadow mode, read the transcripts, and move the dial when it stops surprising you.

• A mandate, not a prompt — Target terms, tradeable terms and walk-away lines are enforced as boundaries on the run — a breach stops it rather than bending it.
• Three levels — Shadow drafts every move for approval. Supervised runs alone and escalates. Autopilot completes the agreement and reports back.
• Caps that bind — Turn, token and spend ceilings per run, enforced server side, so an unproductive negotiation pauses instead of billing.
• One kill switch — An organization-level switch halts every agent — yours and any connected over MCP — and nothing resumes without a human.

An agent you can actually account for

Autonomy is only defensible if the record is complete. Everything the assistant does is attributable after the fact — including what it declined to do.

• Every action on the record: Each tool call logged with its inputs and outcome
• Every action on the record: Agent turns attributed in the room timeline
• Every action on the record: Refused and escalated actions recorded, not dropped
• Every action on the record: Approvals bound to the exact version approved
• Evidence that holds: Document versions addressable and diffable
• Evidence that holds: Negotiation turn log sealed with the agreement
• Evidence that holds: Signer identity captured against the signed version
• Evidence that holds: Court-ready export of the complete record
• Cost you can see: Spend shown per run, not buried in a monthly total
• Cost you can see: AI credits on the plan, prepaid wallets on top
• Cost you can see: Caps enforced before the spend happens
• Cost you can see: External agent usage metered the same way

What you should ask before trusting any agent

• What stops it from agreeing to something I would not? The mandate. It is not advice in a prompt the model can talk itself out of — it is a boundary checked on the run. A move outside it halts the agent and opens a review item with the clause and what accepting would cost.
• Can I see what it would have done before letting it act? Yes. Shadow mode runs the full sequence into a private draft: you read the drafting, the risk calls and every negotiation move it would have made, and nothing reaches the counterparty.
• Does it work if the counterparty is a person, not an agent? Yes, and that is the common case. The assistant participates in the room like any other party — posting positions, applying redlines on clauses and waiting for replies. When the other side does bring an agent, the two negotiate directly.
• How is this different from connecting a model to our documents? A model with document access can read and suggest. The assistant holds a mandate, edits the live instrument, opens negotiations, routes approvals, requests signatures and tracks obligations — and every one of those actions is a logged call against a system of record rather than text in a chat window.
• Can we use our own model or agent instead? Yes. Paqt is an MCP server, so your agent can drive the same surface. It runs under the same mandate, caps, approval gates and audit trail as our own assistant.
• What does it cost to run? AI usage draws on the credits included with your plan plus any prepaid wallet, and every run shows its own spend. Caps are enforced before the spend happens, so an agent cannot quietly become expensive.

This is the whole job. You appear once.

A copilot gives you a better first draft and leaves the other eight stages on your desk. Here is what the assistant does with a real agreement — and the call it makes at each step, because an agent that cannot show its work is not one you can hand a file to.

• Intake: Reads the room instead of asking you to summarize it — The thread is the brief. The assistant pulls the parties, the commercial terms, the attachments that matter and the points still unresolved out of the conversation that already happened.
• Research: Finds the precedent you have already approved — It searches your clause library and executed agreements for the closest matter, so the draft starts from language your organization has signed before rather than from a model's guess.
• Drafting: Assembles the instrument and fills the variables — A complete first draft from the template and clause library, with parties, dates, amounts and schedules populated from the thread — not placeholders for someone else to chase.
• Risk review: Flags what deviates and what it costs — Inbound paper is diffed against your standard clause by clause. Each deviation comes back with its practical effect and the position your mandate says to take.
• Negotiation: Opens the negotiation and works the clauses — Real proposals on specific clauses, inside the mandate, against the counterparty or their agent. It trades where you allowed a trade and holds where you drew a line.
• Escalation: Brings you the decisions, not the transcript — Anything outside the mandate stops. You get the clause, the ask, what it breaches and what accepting would cost — one paragraph, one decision.
• Execution: Routes signature against the agreed version — Signing runs in the same room, on the exact version the negotiation produced, with each signer's identity captured against it.
• Obligations: Turns the executed document into dates — Term, renewal window, notice period and conditions are extracted from the signed agreement, so the next deadline is data rather than a reminder somebody remembered to set.
• Record: Seals a record that survives scrutiny — The conversation, every version, each negotiation turn, the approvals and the signature audit are hashed into a tamper-evident history and exportable as one court-ready package.

An agent is only as useful as the systems it can reach

Paqt speaks Model Context Protocol as a server and as a client. Your agent can run the agreement surface, and our assistant can use the tool servers you grant it — under the same scopes, caps and audit either way.

One set of rules, whichever agent is running. An external agent connected over MCP negotiates under the mandate you authored in Paqt, respects the same turn and spend caps, escalates into the same human review queue, and stops when you throw the organization kill switch.

• Inbound — Your agent drives Paqt: Point any MCP client at Paqt and the agreement surface becomes callable: search rooms, draft instruments, open negotiations, request signatures, stream the evidence package.
• Inbound: Scoped credentials with expiry and rotation
• Inbound: New room access needs a human to approve
• Inbound: Every call attributed in the audit trail
• Outbound — Paqt's assistant drives your tools: Connect your own MCP tool servers and the assistant uses them mid-run — fetching what it needs to finish a stage instead of stopping to ask you for context it could have retrieved.
• Outbound: You choose which servers and tools are allowed
• Outbound: Calls count against the run's spend cap
• Outbound: Outbound calls logged beside the agent's turns