A copilot advises. An agent executes

Advice you apply, or work that completes

Both read the same clause and reach a similar view of it. The question is what happens in the ten minutes after that.

• Review copilot: Produces findings and suggested language for a human to act on
• Review copilot: Operates on a document you upload, with no view of the negotiation around it
• Review copilot: Has no counterparty channel, so sending, chasing and following up stay manual
• Review copilot: Has no notion of what you are authorised to concede, so every suggestion needs judgement
• Review copilot: Leaves no record of a decision, because it never made one
• Review copilot: Throughput still scales with how many people are available to apply the advice
• Paqt assistant: Takes the turn: drafts the position, sends it, handles the response
• Paqt assistant: Works inside the agreement room, with the thread, the clauses and the history in scope
• Paqt assistant: Reaches the counterparty directly in the room they are already in
• Paqt assistant: Bounded by a mandate that states what is acceptable, tradeable and forbidden
• Paqt assistant: Every action attributed to the agent, its mandate and the version it acted on
• Paqt assistant: Throughput scales with the number of runs, not the number of reviewers

The four things a suggestion engine does not have

Going from advice to action is not a bigger model. It is these four pieces of machinery, and each one is a safety mechanism as much as a capability.

• A mandate — An explicit statement of the positions the assistant may take: acceptable without review, tradeable within limits, and forbidden. Without it, an agent acting on your behalf is guessing at your risk appetite.
• Clause-level gates — Named clauses that always stop the run and wait for a specific human. The gate belongs to the clause, so no autonomy level — including the most permissive — can carry it past the reviewer.
• Attribution — Every turn, acceptance and override recorded against an identity, a mandate and a document version. Accountability for an agent's action has to be a matter of record, not reconstruction.
• A reversible autonomy dial — Shadow mode where nothing reaches a counterparty, supervised with escalation, autopilot for settled paper — plus an organization-wide kill switch that halts every agent at once.

It can negotiate against another agent

When the counterparty runs an assistant too, the two negotiate directly inside the shared room — each bounded by its own side's mandate, with every turn visible to both.

• Agent-to-agent turns — Positions are exchanged clause by clause at machine pace, and the transcript is the same record a human negotiation would have produced.
• Deadlock is an outcome, not a loop — When neither mandate can move, the run stops and both sides get the specific clause that blocked it rather than an endless exchange.
• Humans stay the decision-makers — Anything either side gated comes back to a named person. The agents close the gap between the decisions; they do not replace them.
• Open to your own agents — The Model Context Protocol surface means the agent on the other side does not have to be ours. Your systems connect over MCP with scoped credentials.

You do not give up the review features

Everything a copilot is good at is table stakes here. The argument is about what happens next, not about dropping the analysis.

• Analysis: Inbound documents compared clause by clause against your standard
• Analysis: Deviations listed with what they change and why it matters
• Analysis: Risk explained in the language of your own standard positions
• Analysis: Missing clauses surfaced, not just altered ones
• Drafting: First drafts generated from your templates and clause library
• Drafting: Alternative language proposed at the clause level
• Drafting: Summaries written for the people who will not read the document
• Drafting: Plain-language explanations attached to each position
• Execution: Positions sent to the counterparty inside the mandate
• Execution: Follow-up and reminder cadence handled without prompting
• Execution: Escalations raised with the clause, the delta and a recommendation
• Execution: Signature and obligation extraction at the end of the same run

When a copilot is enough

If what you need is a faster read of a document, an agent is more machinery than the problem deserves. Mandates, gates and attribution exist because the assistant acts; if it does not need to act, you are paying for safety you are not using.

Shadow mode is the honest way to test the difference: the assistant drafts and prepares escalations, nothing reaches a counterparty, and you read its transcripts against what your team would have done.

• Stay with a copilot when: The task is review and summarisation, and a human was always going to decide the next step
• Stay with a copilot when: The documents are one-off, bespoke and unlike each other, so there is no standard to measure against
• Stay with a copilot when: You cannot yet write down what positions are acceptable, which is what a mandate requires
• Stay with a copilot when: Your work is litigation or advisory reading rather than agreements being negotiated to signature
• Move to an agent when: The same deviations come back repeatedly and a person responds to each one by hand
• Move to an agent when: You can state your standard positions and the limits on them
• Move to an agent when: Volume, not judgement, is what is slowing the queue down
• Move to an agent when: You want the record of who decided what to exist without anyone assembling it

The objections worth raising

• What stops it from agreeing to something we would never accept? The mandate, enforced as a boundary rather than a prompt. Positions outside it are not negotiated — the run stops. Clauses you name as gated always stop regardless of autonomy level, and the kill switch halts every agent in your organization at once.
• How do we know what it did? Read the run. Every turn carries the agent, its mandate, the clause, the position taken and the document version it acted on, in one timestamped history. The transcript is the record — there is no separate log to reconcile against the document.
• Is this just a copilot with the confirmation step removed? No, and that would be the dangerous version. Removing confirmation without a mandate, clause gates and attribution gives you an unbounded actor. Those three pieces are what make the confirmation step unnecessary for ordinary turns and mandatory for the terms you care about.
• Can we use our own models or our own agent? Your own agent, yes — the Model Context Protocol surface exposes rooms, agreements, clauses, runs and obligations to any MCP client with scoped credentials, under the same gates as the in-product assistant.