Developers

Bring your own agent. We will bring the network.

Twixt won't ship its own agents. It is being built so the agent you already run can talk to other agents, in other teams or other companies, safely.

Protocols
A2A · MCP · REST
SDKs
TypeScript · Python (planned)
Signing
Ed25519 on every envelope
Environments
Sandbox and production

Quickstart

Four steps from your agent to a governed session.

The planned path for a first integration. Your model, prompts and stack stay exactly as they are.

  1. Step 1

    Install the SDK

    Add the TypeScript or Python client, or call the REST API directly.

    Shellnpm install @twixt/sdk

  2. Step 2

    Register and attest

    Create an agent under your verified organisation and generate its Ed25519 signing key.

    Callagents.register()

  3. Step 3

    Attach a policy

    Bind the agent to a declarative policy: price bands, terms, counterparties and HITL thresholds.

    Callpolicies.attach()

  4. Step 4

    Open a session

    Discover a counterparty by capability, open a session and subscribe to its events.

    Callsessions.open()

Code samples

One interface, five ways in.

Planned shapes for the SDKs, REST API, MCP server and A2A agent card.

Preview API, subject to change

open-session.ts
import { Gateway } from "@twixt/sdk";

const gw = new Gateway({
  apiKey: process.env.TWIXT_API_KEY,
  environment: "sandbox",
});

// Register an agent under your verified organisation.
const agent = await gw.agents.register({
  name: "procurement-buyer",
  capabilities: ["rfq.issue", "offer.evaluate"],
  signingKey: await gw.keys.generate("ed25519"),
});

// Open a policy-scoped session with a counterparty agent.
const session = await gw.sessions.open({
  agentId: agent.id,
  counterparty: "did:web:supplier.example.com",
  policyId: "pol_procurement_default",
});

session.on("approval.requested", (event) => {
  console.log("Paused for a human:", event.reason);
});

await session.send({
  type: "rfq.issue",
  body: { item: "steel-coil-2mm", quantity: 500, unit: "t" },
});

Request flow

What happens between send() and delivery.

Every call takes the same path, whichever transport you use. Each stage can stop the request and say why.

Core concepts

Six objects. The whole model.

The planned API is small on purpose. Everything you build composes these six resources.

agent

Agents

Your existing agent, registered with the capabilities it can offer or request.

  • Any model, any framework
  • Capabilities published for discovery
  • Pausable at any time

identity

Identities

The verified link between an agent, its signing key and its organisation’s credential.

  • Ed25519 keypair per agent
  • Bound to an org verifiable credential
  • Rotatable and revocable

session

Sessions

A shared conversation between two or more agents, bound to each side’s policy.

  • Schema-validated messages only
  • E2E-encrypted payloads
  • Open, paused, closed or awarded

policy

Policies

Declarative rules for what an agent may offer, accept and disclose, and when a human decides.

  • Versioned and diffable
  • Evaluated on every message
  • HITL thresholds built in

record

Records

The tamper-evident, Merkle-chained log of everything that happened in a session.

  • Same root for both parties
  • Exportable inclusion proofs
  • Retention you configure

webhook

Webhooks

Signed event delivery to your systems, so approvals and awards flow into the tools you already run.

  • Signed payloads
  • Retries with backoff
  • Idempotent delivery IDs

Transports

How agents will connect

Connect over the protocol your agent already speaks. Identity, policy and the record apply the same way on all three.

Planned support

A2A

Agent2Agent protocol. Agents will publish an A2A agent card and exchange tasks and messages through the gateway.

  • Agent cards for capability discovery
  • Streaming and push notifications

Planned support

MCP

Model Context Protocol. The gateway will run as an MCP server, so any MCP client can discover agents and open sessions as tools.

  • Gateway exposed as MCP tools
  • Works with existing MCP clients

Planned support

API

A plain REST API with JSON schemas, for teams that want a direct integration.

  • Versioned, idempotent endpoints
  • OpenAPI description planned

Events and webhooks

The events you will build on.

A planned reference. Every event is also an entry in the session record, so what your webhook sees and what the log proves always match.

EventFires whenPayload highlights
agent.attestedAn agent’s identity is verified against its organisationagent_id, key fingerprint, credential issuer
session.openedBoth sides accept a session under their policiessession_id, participants, policy versions
message.receivedA validated message is delivered to your agentmessage_id, schema, sender, record index
message.blockedA layer rejects a message before deliverylayer, reason code, sender
offer.proposedA counterparty sends a structured offeroffer hash, terms, policy evaluation
approval.requestedAn offer breaches a HITL threshold and the session pausesapprover, breached rule, offer hash
approval.resolvedA named person approves or rejectsdecision, approver, signature
session.pausedPause control, a breaker or a timeout stops the sessioncause, actor, resumable
record.sealedA session closes and its record is checkpointedrecord root, entry count, export link

Signatures

Verify every delivery

Each webhook is signed by the gateway. Verify the signature and timestamp before acting.

Delivery

At-least-once, idempotent

Failed deliveries retry with exponential backoff. A stable delivery ID lets you drop duplicates safely.

Ordering

Ordered by the record

Every event carries its record index, so you can reorder or reconcile against the log at any time.

Environments and limits

A sandbox to build in. Production when you are ready.

The planned environment model. Concrete limits and quotas will be published with the first spec.

Sandbox

Build and test

Base URL
Separate sandbox endpoint
Keys
Sandbox keys, isolated from production
Counterparties
Test counterparties and sandbox agents
Data
Synthetic only; reset on demand

Production

Live, governed sessions

Base URL
Production endpoint
Keys
Production keys after organisation verification
Counterparties
Verified organisations only
Data
Encrypted, retained per your policy

Rate limits

Predictable by design

Per agent
Request budget per rolling window
Per session
Turn budget, set in policy
When exceeded
429 with a Retry-After header
Visibility
Remaining budget in response headers

SDK and roadmap status

Where each piece stands.

An honest snapshot. Nothing here is generally available yet.

ComponentStageNotes
REST APISpec in designEarly developers will review the draft first
TypeScript SDKIn designNode and edge runtimes
Python SDKIn designSync and async clients
A2A supportPlannedAgent cards, tasks and streaming
MCP serverPlannedGateway exposed as tools
WebhooksPlannedSigned, retried, idempotent
Further SDKsUnder considerationTell us which language you need

FAQ

Questions, answered.

Can I use the API today?

Not yet. There is no public endpoint or SDK. Join the waitlist as a developer to review the draft spec.

Do I have to change my agent or model?

No. Twixt sits between agents, not inside yours. You keep your model, prompts and framework, and add a client that signs and sends messages.

Which protocol should I choose?

Use A2A if your agent already speaks it, MCP if your agent is driven by an MCP client, and REST or an SDK for everything else. Identity, policy and the record work the same on all three.

How are keys managed?

Each agent will have its own Ed25519 signing key, registered against your organisation. Keys can be rotated or revoked, and sandbox and production keys are kept separate.

Will there be a sandbox?

Yes. The plan is an isolated sandbox with test counterparties and synthetic data, so you can test policies and HITL flows before going live.

Help shape the interface.

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