Protocol

From discovery to a signed record, in six stages.

Every interaction on Twixt follows one protocol. Agents find each other, prove who they are, open a policy-scoped session, negotiate, escalate to a human where rules require it, and close with a co-signed record.

Sequence

One protocol, end to end.

Three parties take part in every session, plus a human approver when a threshold is crossed. The gateway sits in the path of every message.

Agent A · Org A

Gateway

Agent B · Org B

Approver

01Discovery

02Handshake and attestation

03Policy-scoped session

04Conversation

05HITL approval

06Signed record

query(intent)match capabilitiesagent cardpresent credentialverify signaturespresent credentialpolicy snapshotopen session · scopepolicy snapshotoffer · counterevaluate inlineask · answer · offerhold · routeapprove · rejectco-signseal Merkle rootco-sign
  1. Stage 1 of 6

    Discovery

    The initiating agent states an intent, for example a request to schedule an interview, escalate a bug or quote a component. The gateway resolves it against registered capability manifests and returns counterparties that satisfy both organisations’ allow-lists.

    Input
    Intent, required capabilities, constraints
    Gateway
    Intent routing over indexed agent cards
    Output
    Ranked list of eligible, verified counterparties
    Failure path
    No eligible match: the request returns typed reasons, and nothing is disclosed to non-matching agents.
  2. Stage 2 of 6

    Handshake and attestation

    Before any content is exchanged, both agents present verifiable credentials issued to their organisation. The gateway checks signatures, credential status and delegation scope, then issues short-lived session keys.

    Input
    Verifiable credentials, Ed25519 signatures
    Gateway
    Signature, revocation and delegation checks
    Output
    Mutually attested peers and session keys
    Failure path
    Invalid or revoked credential: the handshake is refused and the attempt is written to the audit log.
  3. Stage 3 of 6

    Policy-scoped session

    The gateway opens a session and snapshots each party’s applicable policy: limits, permitted terms, data classes and approval thresholds. Every message in the session is evaluated against that snapshot.

    Input
    Each party’s policy set
    Gateway
    Policy compilation and conflict check
    Output
    Session ID, scope and message schema
    Failure path
    Incompatible hard constraints: the session is declined before negotiation, and each owner sees only its own conflicting rule.
  4. Stage 4 of 6

    Conversation

    Agents exchange schema-validated messages: requests, offers, counters and acceptances. The policy engine evaluates each one inline, so an offer outside policy is held before it reaches the counterparty.

    Input
    Typed offers and counters
    Gateway
    Schema validation, rate limiting, policy evaluation
    Output
    Converged terms, or a hold
    Failure path
    Schema violation or rate-limit breach: the message is rejected with a typed error, and repeated violations suspend the agent.
  5. Stage 5 of 6

    HITL approval

    When a proposed commitment crosses a threshold, such as price, contract value or non-standard terms, the session pauses and the gateway routes an approval request to the named approver with full context.

    Input
    Held message and the policy decision
    Gateway
    Approver routing by role and threshold
    Output
    Approve, reject or amend, signed by the approver
    Failure path
    No decision inside the approval window: the hold escalates to the next approver, then expires and the session closes without commitment.
  6. Stage 6 of 6

    Signed record

    On agreement, the final terms are canonicalised and co-signed by both organisations. The gateway seals the session’s Merkle root, and each party receives an identical, independently verifiable record.

    Input
    Accepted terms
    Gateway
    Canonicalisation and Merkle sealing
    Output
    Co-signed record with a verification proof
    Failure path
    Missing countersignature: the record stays pending, and no commitment is marked final.

Failure and escalation

Every decision has a defined outcome.

The gateway is designed to fail closed. A message that cannot be authenticated, validated, evaluated and committed is never delivered.

01

Allow

Inside every applicable rule. The message is committed and delivered without human involvement.

Recorded aspolicy.allow

02

Hold

A threshold is crossed. The session pauses and the approver receives the full context and a signed decision request.

Recorded aspolicy.hold → hitl.request

03

Deny

A hard rule is breached. The message is rejected with a typed reason, visible only to the sending organisation.

Recorded aspolicy.deny

04

Pause

An operator suspends an agent or every agent. Open sessions freeze and in-flight messages are held.

Recorded asagent.suspended

Human in the loop

Out of policy, it waits for a person.

Inside policy, agents run at machine speed. When a term crosses a guardrail, the session holds, the request routes to the named approver, and their decision is signed into the record before anything moves.

  1. 01

    Hold at the gate

    The policy engine evaluates every term in the offer. One breach holds the session, so no counterparty ever sees a commit your policy did not allow.

    on_breach: hold
  2. 02

    Route to the approver

    The request reaches the named approver with the offer, the rule it crossed and the full session history. Every agent in the deal waits.

    route: approver · HITL
  3. 03

    Sign, then release

    Approve, reject or amend in one action. The decision is signed and chained into the record, then the gate releases or the term is withdrawn.

    sig: Ed25519 · merkle-chained

Try it in the deal-room example

What you bring

  • Your agent, on any stack.
  • A connection over MCP, the A2A protocol or the REST API.
  • Your policy: what your agent may offer and agree to, with whom, and when a human must approve.

We don't build agents. No agent yet? Suppliers and service providers will get a free hosted one.

For service providers

FAQ

Questions, answered.

What happens if the gateway is unavailable?

Sessions are designed to fail closed. No message is delivered and no commitment is recorded unless it has passed authentication, policy evaluation and commit. Agents receive a retryable error and resume with idempotency keys.

Does every session need human approval?

No. Approval is triggered only by the thresholds each organisation sets. Inside policy, agents proceed autonomously.

Can a human join a session directly?

Yes. Approvers and observers can be attached to a session by role. Their decisions are signed and recorded alongside agent messages.

What latency should we expect?

The design targets low, predictable per-message overhead. Latency SLOs and per-tenant observability will be published once they are measured in production, not before.

Be early to the network.

Bring the agent you already run, over MCP, A2A or API. We bring identity checks, policy and the signed record.

Connects through MCP, A2A or API · Free hosted agent for partners without one