Trust infrastructure for autonomous commerce

The trust layer for autonomous commerce.

Let your AI agents safely spend money with approvals, budgets, policies, and portable receipts—across any payment provider.

Works across every model, framework, payment rail, and cloud.

Start in Sandbox Read the Quickstart

Run without signing up

Terminal commandSwipe to view long lines

paybond dev loop --offline

Append-only ledger
Signed Portable Receipts
Deterministic policy
Replayable audit exports

paybond.instrument.ts

Code exampleSwipe to inspect long lines

const runtime = await paybond.instrument({
  policy: "travel",
  tools,
});

Bind per session with await instrumented.bind({ intentId, capabilityToken }) — sandbox shortcut: paybond.agent({ policy: 'travel', tools })

paybond dev trace

sandbox

Transaction trace

operation travel.book_hotel

Policy approved
—
Tool executing
—
Evidence attached
—
Portable Receipt issued
—

View full trace replay →

Agent spend pipelineSwipe across steps

Agent
PaybondPolicy • Evidence • Settlement • Portable Receipt
External Service
Evidence
Portable Receipt

Authority
Every autonomous action stays within delegated authority.
Proof
Prove every transaction completed successfully.
Receipts
Export verifiable Portable Receipts for audits and disputes.

AI agents can already purchase software, negotiate contracts, reserve hotels, provision cloud infrastructure, and move funds.

Existing payment systems were designed for humans—not autonomous systems that need verifiable authorization, evidence, and replayable transaction records.

Why Paybond?

Payment processors move money. Model providers run inference. Paybond owns the trust layer between them — signed policy, evidence, settlement, and an open receipt standard no single vendor can credibly neutralize.

Every transaction becomes a Portable Receipt.
Every decision is backed by evidence.
Every policy is enforced consistently across every runtime.
Every action is reconstructable years later.

Portable Receipt

A cryptographically signed record containing the authorization, policy, evidence, and settlement outcome for every AI transaction.

Every AI transaction produces a cryptographically verifiable Portable Receipt.

paybond.agent_receipt_v1 composes authorization, model context, payment proof, and evidence into one signed, offline-verifiable record — the artifact autonomous commerce has been missing.

The benchmark for governed AI commerce: Does your platform emit Paybond Portable Receipts?

Open standard
paybond.agent_receipt_v1, published at /.well-known/agent-receipt-v1.json
Privacy by design
Digest-only references — no raw prompts, arguments, or evidence payloads in the receipt envelope
Composable proofs
Authorization, model context, payment proof, and evidence in one signed record

Agent receipt standard →

Harbor

The transaction operating system for AI.

Signed intents, escrow, evidence evaluation, and settlement — the engine behind every Portable Receipt.

Explore Harbor →

Try it in sandbox

Initialize a travel policy scaffold and rehearse spend authorization plus evidence — no integration code required.

Free Developer sandbox · CLI smoke test · No integration code required

Initialize

Terminal commandSwipe to inspect long lines

npx -p @paybond/kit paybond init --solution travel --non-interactive

Smoke test

Terminal commandSwipe to inspect long lines

paybond agent sandbox smoke \
  --preset travel \
  --result-body '{"status":"completed","cost_cents":18700}' \
  --format json

paybond init

Zero-login local try

Runs middleware smoke locally without signing up.

Terminal commandSwipe to view long lines

paybond dev loop --offline

Paybond CLI →

Neutral across every agent runtime

One policy layer with no vendor lock-in — not a bet on any single framework.

Harbor settles across every rail

Stripe, MPP, Adyen, Flutterwave, Paystack, ACH, x402, and Shopify — Harbor executes and settles agent intents without replacing your existing stack.

Built into Paybond

Start with a policy template

Choose a built-in template for your workflow, then customize it as your agent grows.

Domain templates

Compose →

What you type

paybond.instrument.ts

const runtime = await paybond.instrument({
  policy: "travel",
  tools,
});

Click a template to preview the paybond.instrument() call — scaffold a starting policy file with paybond init, then evolve it as your agent grows.

Use template →

Trust lifecycle

From unguarded tool calls to Portable Receipts

Most agents call external services with no guardrails. Paybond inserts a trust layer at that boundary — then runs a signed lifecycle ending in a Portable Receipt on every side-effecting call.

The service boundary

Without trust infrastructure vs. with Paybond

One trust layer between your agent and every external service — authorize before side effects, verify proof after.

Without Paybond

Agent
External service
Hope nothing goes wrong

With Paybond

Agent
Policy
Spend check
Service
Evidence
Settlement
Portable Receipt

The lifecycle

The lifecycle on every call

Policy, authorization, evidence, and settlement — in order, on every guarded tool call.

Settlement phasesSwipe across steps

Set policy & budgetParties, spend envelope, and completion rules

Authorize spendFund the intent and issue a scoped capability

Check before service runsAuthorize external service calls before side effects

Verify evidenceEvaluate signed completion proof

Portable Receipt & settlementRelease, refund, and exportable Portable Receipt

Paybond Kit · TypeScript and Python

Try it in your repo

Install the CLI, instrument your tools, and run sandbox smoke from your project — TypeScript and Python kits share the same semantics.

Need a single paid handler without an agent framework? Use paybond init guardrail. Production attach, settlement rails, and policy binding live in the quickstarts.

Initialize in your repo
Run paybond init to scaffold paybond.policy.yaml and framework integration stubs — or skip straight to smoke if you only need a CLI rehearsal.
Run sandbox smoke
paybond agent sandbox smoke binds a travel intent, authorizes spend, executes a guarded tool call, and submits completion evidence — no application code required.
Open a sandbox session
Load PAYBOND_API_KEY from .env.local with expectedEnvironment so every Harbor call stays tenant-scoped automatically.
Instrument your tools
paybond.instrument() loads a policy preset and wraps side-effecting tools; bind() attaches intentId and capabilityToken for production attach.
Wire into your runtime
Register runtime.tools with OpenAI Agents, LangGraph, Claude, MCP, or a custom orchestrator. Sandbox-only trials can use paybond.agent() instead — no bind required.

Middleware trace replay Open demo hub

Continue in the docs: agent quickstart · one-command guardrails · TypeScript quickstart · Python quickstart · support matrix · agent middleware.

Sandbox quickstart

Step 1paybond initagent sandbox smoke

Step 2paybond.instrument()

Step 1 · CLI

terminal

Terminal commandSwipe to inspect long lines

npx -p @paybond/kit paybond init --solution travel --non-interactive

npx -p @paybond/kit paybond agent sandbox smoke \
  --preset travel \
  --result-body '{"status":"completed","cost_cents":18700}' \
  --format json

Step 2 · App

paybond.instrument.ts

Code exampleSwipe to inspect long lines

import { Paybond } from "@paybond/kit";

const paybond = await Paybond.open({
  apiKey: process.env.PAYBOND_API_KEY!,
  expectedEnvironment: "sandbox",
});

const instrumented = await paybond.instrument({
  policy: "travel",
  tools: {
    "travel.book_hotel": async () => ({
      status: "completed",
      cost_cents: 18_700,
    }),
  },
});

const runtime = await instrumented.bind({
  intentId,
  capabilityToken,
});

const agent = new Agent({
  model: "gpt-5",
  tools: runtime.tools,
});

// Sandbox shortcut: await paybond.agent({ policy: "travel", tools })
await paybond.aclose();

The trust stack

Four product surfaces follow one trust lifecycle: Kit integrates → Harbor settles → Ledger records → Signal builds standing. Each layer adds policy, signed settlement, audit records, or portable standing.

Agent runtime
Kit
Developer SDK
Harbor
Agent transaction engine
Ledger
Evidence & provenance
Signal
Standing & reputation

Kit integrates → Harbor settles → Ledger records → Signal builds standing

Every autonomous transaction on the internet should be verifiable.

AI agents deserve the same trust infrastructure humans have — authorization before action, evidence after, and a Portable Receipt anyone can verify.

2026SDK
2027Middleware
2028Platform
2029Open receipt specification
2030Trust protocol
2032Industry standard

Paybond is built to become the default layer every other SDK, framework, and payment provider assumes exists.

Start with the path that matches your rollout

Enterprise fleets, outcome-verified escrow, developer integration, or a comparison against DIY guards — pick the entry point that matches the job you need done.