Your agents can spend. Funds don't release until the work is proven.

Authorize the action. Verify the outcome.

Release or refund based on signed completion evidence. Your rails, your runtime, one signed receipt. Wrap paid tools with middleware that attaches proof to the same settlement trail — policy checks stay supporting.

Build a proof-gated tool call Go live with Pay as you go Read Kit docs Agent middleware

Self-serve Sandbox, Pay as you go, and Credits — plus Design-partner pilots and Custom needs. Compare Sandbox, PAYG, and Credits.

One wrapped tool call — authorize → execute → verify → settle

call
agent.tool_call("book_hotel", spend_cents=48000)
Your existing tool call; Kit wraps the settlement boundary around it.
auth
paybond.authorize → spend bound
Authorize operation, budget, and completion rule before the tool runs.
run
tool executed → booking confirmed
Your existing tool implementation runs exactly as before.
verify
paybond.verify(evidence)
Submit completion evidence against the signed rule.
done
settlement: released
Release, refund, or review — one signed receipt finance can replay.

What Kit adds to your runtime

The SDK covers the application path around settlement so product teams do not have to rebuild it inside every agent workflow.

Authorize spend
Open a session with service-account credentials and bind each paid action to operation, budget, and completion rule — without accepting a tenant from the tool call.
Verify completion before release
Submit structured evidence through the same client so release, refund, disputes, and exports refer to verified delivery.
Keep proof with the work
Authorization, evidence, and outcome stay on one settlement trail finance can verify outside the live console.
Name a rail; never a destination
Request a supported settlement rail by name while account and wallet destinations remain tenant-owned server configuration.

Paybond Kit · TypeScript and Python

Sandbox smoke in minutes, production attach in one API

Run paybond init and paybond agent sandbox smoke from the CLI, then wire paybond.instrument() with bind() in @paybond/kit or paybond-kit — policy presets guard paid tools without manual intent wiring.

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 Paybond 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.

Open proof lab Middleware trace replay

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();

Supported paths, without guessing

Kit is the public SDK surface for product teams integrating Paybond. The support matrix documents the current languages, agent framework patterns, and settlement rails.

Agent middleware
PaybondAgentRun, PaybondToolRegistry, and automatic evidence for multi-tool agents — model-agnostic core in TypeScript and Python.
TypeScript
@paybond/kit for modern Node.js runtimes, with quickstarts and example projects for backend integrations.
Python
paybond-kit for Python 3.11+, including published wheels with the native signing extension.
Agent frameworks
Wrappers for OpenAI, Gemini, Claude/Anthropic, local models, LangGraph, MCP hosts, CrewAI-style tools, and custom runtimes.
MCP and LangGraph
Use paybond-mcp-server for MCP-compatible hosts, or the LangGraph integration hooks when a graph node needs a spend check before a paid tool runs.
Settlement rails
Stripe Connect, Stripe ACH Direct Debit, and x402/USDC on Base are the supported public rails today.

What Kit covers

Kit covers application flows
Use it for sessions, signed spend intents, spend authorization, allowed-action checks, evidence submission, selected protocol helpers, and read-only Signal data.
Operators still confirm settlement
Release and refund confirmation remains an operator-reviewed workflow in the console, or a direct API call if your rollout is designed that way.

Start from the right guide

Agent middleware Paybond CLI Coding-agent setup One-command guardrails TypeScript quickstart Python quickstart Support matrix

How a Kit-backed workflow runs

From agreement setup to evidence submission, the SDK keeps the settlement steps close to the workflow that needs them.

Step 1
Open an SDK session
Start with service-account credentials issued for one tenant and environment.
Step 2
Authorize spend
Bind operation, budget, completion rule, evidence shape, allowed operations, and settlement rail before the tool runs.
Step 3
Execute the tool
Your agent or application runs the paid tool in the runtime you already operate.
Step 4
Verify evidence
Submit the signed result payload and artifacts that prove what happened.
Step 5
Settle the outcome
Funds release on pass — or refund on fail — with receipts, exports, and review records downstream.

Keep proof-gated release where the work runs.

Your application owns planning and execution. Kit makes authorize → execute → verify → settle explicit at the tool-call edge.

Guarantees

Tenant scope comes from authenticated credentials.
Release waits on signed completion evidence.
Rails are requested by name; destinations remain in tenant settlement config.
Evidence stays structured for review, exports, and disputes.

View support matrix

Designed for agent runtimes

Use Kit where workflows already run: orchestrators, tool routers, sandboxes, and multi-tenant application backends.

Agent orchestrators
Add spend authorization and settlement checks around tool calls in the runtime you already run.
Tool routers and sandboxes
Gate side-effecting actions with approved operation names from your own application namespace.
Multi-tenant platforms
Keep each customer workspace tied to its own credentials, settlement configuration, and evidence records.