Your agent, our agreements layer

Everything the assistant can do, your agent can too

The same operations that power Paqt's own assistant are exposed as MCP tools. There is no second-class API — your agent and ours call the same surface under the same rules.

• Rooms and threads — Search rooms, read message history with attachments, and post as an identified agent so humans always know who is speaking.
• Documents and versions — Draft from templates, patch clauses, read any version's metadata, and diff two versions without leaving the protocol.
• Negotiations — Open a negotiation on a clause, submit offers and counters, accept inside a mandate, and read the full turn log.
• Signature flows — Request signatures, track signer state, and read back the identity capture recorded against the signed version.
• Exports and evidence — List the export catalog, stream a court-ready package, and verify a certificate hash against the agreement history.
• Events — Subscribe to webhooks so your agent wakes on a counter-offer or a completed signature instead of polling for one.

Scoped, approved, and on the record

An agent credential is not a password to your workspace. It is a narrow grant — these scopes, these rooms, until this date — and everything it does is attributable.

• Scoped credentials — Mint a credential with explicit scopes and an expiry, rotate it without downtime, and revoke it the moment a project ends.
• OAuth for third parties — External tools authorize through a consent screen rather than a shared secret, so a human always sanctions the first connection.
• Room-level approval — An agent asking for a room it has not been granted raises an access approval. A person grants or denies it; the agent waits.
• Attributable calls — Every tool call is written to the audit trail with the credential, the scope it used and the object it touched — including the refusals.

The unglamorous parts, already handled

Connecting an agent to a system of record is mostly failure handling and forensics. That work is done.

• Safety: Per-credential scope enforcement on every call
• Safety: Human approval gate for new room access
• Safety: Organization kill switch halts all agents
• Safety: Refused calls recorded, not silently dropped
• Reliability: Signed webhooks with automatic retries
• Reliability: Dead-letter queue you can inspect and replay
• Reliability: Idempotent writes for safe retries
• Reliability: Key rotation without dropping in-flight calls
• Forensics: Full call log per credential
• Forensics: Agent actions attributed in the room timeline
• Forensics: Tamper-evident agreement history
• Forensics: Court-ready export of the whole record

What developers ask first

• What can an agent connected over MCP actually do? Exactly what its scoped credential grants: the rooms it may enter and the operations it may call. It can read agreement state, propose clause changes, open negotiations, request approvals and move a workflow forward. It cannot sign, alter a version locked for signature, or change the mandate it runs under.
• Does an external agent get looser rules than yours? No — the same ones. Clause-level review gates, mandates, turn and spend caps and the organization-wide kill switch apply identically to an agent you wrote and to Paqt's own assistant. Arriving over the protocol grants no extra authority.
• How do we see what our agent did? Every tool call is logged with its inputs and effects, and every resulting action is attributed to that agent in the room timeline. Refused calls are recorded too, so a permission problem is visible rather than silent.
• Can Paqt's assistant call our tools instead? Yes, that is the other direction. Point the assistant at an MCP server you run and it can call your tools as part of a run, under the same mandate and with every call recorded.

Bring your own model, keep our guardrails

An agent connected over MCP runs under the same mandate, caps and review queue as Paqt's own assistant. That means you can swap in your own model and tooling without giving up the controls that make autonomy safe — and without building the audit trail yourself.

• Your agent negotiates under a mandate you author in Paqt
• Turn and spend caps apply to external agents too
• Escalations land in the same human review queue
• One kill switch covers your agents and ours