One SDK. One call. Your agent discovers a provider, gets identified, pays on the right rail, and walks away with a signed receipt — instead of burning spend on sketchy APIs, card failures, and "let a human do it."
Live · four scenarios on loop · no network calls made
Agents already spend money. They hit APIs, burn credits, book travel, buy compute. But when a charge shows up and the customer asks "what is this?" — most stacks don't know. TrueCom does.
Both panels answer the same query. One scrapes an open bazaar — spam, dead endpoints, typo-squats. The other hits TrueCom's ranked capability index with trust, telemetry, and receipts baked in.
Most APIs ship human-readable docs and leak implementation. TrueCom turns them into typed capability cards — inputs, budget, consent, rail support — and serves them to agents with the same schema every time.
No rewrite. No infra. Pick your language and framework — the SDK is a 3–6 line diff. Already on OpenAI, Anthropic, LangChain, CrewAI, or a raw HTTP loop? We've got an adapter.
One dependency. Zero peer requirements.
$ npm install @truecom/sdk
$ pip install truecom
$ go get github.com/truecom-ai/sdk-go
$ curl -I https://api.truecom.ai/v1/ping
$ npx @truecom/mcp-server --install
Bind a DPoP key to your agent identity. Issued once, rotates on a schedule.
import { TrueCom } from "@truecom/sdk"; const tc = new TrueCom({ apiKey: process.env.TRUECOM_KEY, did: "did:webvh:acme.ai/agent-flights", scopes: ["travel:book", "inference:wrap"] });
from truecom import TrueCom tc = TrueCom( api_key=os.environ["TRUECOM_KEY"], did="did:webvh:acme.ai/agent-flights", scopes=["travel:book", "inference:wrap"] )
import "github.com/truecom-ai/sdk-go" tc, _ := truecom.New(truecom.Config{ APIKey: os.Getenv("TRUECOM_KEY"), DID: "did:webvh:acme.ai/agent-flights", Scopes: []string{"travel:book"}, })
# Request a short-lived token from your stored DPoP key $ curl -X POST https://api.truecom.ai/v1/token \ -H "x-tc-did: did:webvh:acme.ai/agent-flights" \ -H "x-tc-dpop: $(tc dpop-proof)"
# MCP server auto-registers your agent with your API key # Claude, Cursor, any MCP client gets ~/tools/truecom export TRUECOM_KEY=tc_live_••• export TRUECOM_DID="did:webvh:acme.ai/agent" npx @truecom/mcp-server --stdio
Discover → select → pay → receipt. One primitive covers the whole loop.
// One call. Same shape for every rail and every vendor. const result = await tc.transact({ intent: "book flight SFO→NRT, aisle, ≤ $1,200", budget: { max: 120000, currency: "USD" }, consent: "user-approved" }); // → result.receipt ed25519-signed, anchored, auditable // → result.provider "kayak-agent" (trust 0.92) // → result.rail "agentpay"
result = tc.transact( intent="book flight SFO→NRT, aisle, ≤ $1,200", budget={"max": 120000, "currency": "USD"}, consent="user-approved" ) # result.receipt, result.provider, result.rail
result, err := tc.Transact(ctx, truecom.Request{ Intent: "book flight SFO→NRT, aisle, ≤ $1,200", Budget: truecom.Budget{Max: 120000, Currency: "USD"}, Consent: "user-approved", })
$ curl -X POST https://api.truecom.ai/v1/transact \
-H "authorization: Bearer $TC_TOKEN" \
-H "x-tc-dpop: $(tc dpop-proof)" \
-d '{"intent":"book flight SFO→NRT, aisle, ≤ $1,200",
"budget":{"max":120000,"currency":"USD"},
"consent":"user-approved"}'
// Your MCP client now has the tools: tools.truecom.discover({ intent: "…" }) tools.truecom.transact({ intent: "…", budget, consent }) tools.truecom.verify(receipt) tools.truecom.dispute(receipt, { reason: "INS-01" })
Each stage produces a signed, auditable event. Your agent writes code against one verb — tc.transact() — and TrueCom runs the entire commerce cycle underneath.
Tap a rail. The call shape stays identical. What changes is currency, finality, fees, and which counterparty on the other side can actually settle against it. Pick by constraint — not by integration effort.
// Same line for every rail below. // TrueCom picks the counterparty on its side. const r = await tc.pay({ rail: "ucp", intent: "buy 500 usb-c cables · NET-30", budget: { max: 240000, currency: "USD" }, consent: "procurement:auto" }); // → r.receipt ed25519-signed · anchored // → r.finality T+0 · PO confirmation // → r.provider monoprice-b2b
Click any scenario to see the exact call, the rail that runs it, and the receipt that comes back. Agent commerce isn't one thing — it's a substrate that settles B2B procurement, travel, inference spend, in-app micropayments, and agent-to-agent delegation against the same receipt format.
Scrub the timeline. Watch state change, events fire, and webhook deliveries hit subscribers — or press PLAY to watch one contract flow from hire through settle in real time.
Every dispute sits in exactly one state. Every transition is signed. Click a state to see who can move it, what evidence is required, and the downstream webhook payload. The whole graph is a spec — not a playbook in a PDF.
Paste any commerce event. We show the Merkle proof path, verify the signature, and resolve to the anchored root — client-side, against a pinned test vector. The same verifier runs in the SDK.
TrueCom's trust score is a 7-component composite. Drag any weight to see how the final score changes and which tier a provider qualifies for. Weights normalize to 1.0 — you always see the whole picture.
AP2 · Visa TAP · Mastercard VI L3 · x402 · UCP · ACP. Pick one to see how TrueCom translates the same agent intent into each protocol's native wire format — same input, different payload.
TrueCom is built as a flat substrate, not a tower. Each primitive has its own endpoint and can be used independently — discover without settling, verify without having issued, reconcile receipts from elsewhere.
Ranked capability index. Trust floors, latency SLOs, budget-aware.
tc.find(query)
DID + DPoP per agent. Scopes declared, consent replayable.
tc.auth(did, scopes)
Budget ceiling in, agreed price + rail out. No back-channel.
tc.quote(intent)
10 rails: UCP, x402, AgentPay, TAP, A2A, card, wire, ACH, RTP, escrow.
tc.pay(quote)
Ed25519-signed events. Anchored. Exportable. One lookup per dispute.
tc.verify(receipt)
Reputation + webhooks. Fraud deltas. Disputes in 7 defined states.
tc.dispute(receipt)
TrueCom is the commerce substrate for the broader Good Ventures Lab stack. If you're running R1, CloudSwarm, RelayGate, or RelayOne, TrueCom is already wired in — receipts, rails, scopes, and identity flow through the same event bus you're already paying into. One substrate, four natural surfaces.
R1's skill pipeline auto-injects TrueCom alongside STOKE. Any skill that touches external money — procurement, inference, travel — emits a signed receipt into the R1 ledger graph. The supervisor treats a missing receipt as a governance violation, not a warning.
// R1 skill · receipt is auto-attached to the ledger skill("procure.cables", async () => { const r = await tc.transact({ intent: "500 usb-c · NET-30" }); return stoke.attest(r.receipt); // enters L2 ledger });
CloudSwarm template agents get a TrueCom budget pool per tenant. Each agent in the fleet draws from it under its own DID — so you see which agent spent what, not just which tenant. The sovereign CanadianClaw instance runs the same rails against BC-resident settlement.
// CloudSwarm template · pool-level budget, per-agent receipts swarm.template("research-100", { pool: { budget: 50000, currency: "USD" }, agents: 100, rail: "x402", // per-call inference spend on: { receipt: tc.ledger.attach } });
RelayGate's ContextWorkers intercept every agent egress. TrueCom's scope + budget policy runs inline — block a call, require HITL for >$100, or rewrite to a cheaper rail. The policy is the ContextWorker; the ContextWorker can embed inline R1 if it needs to reason.
// RelayGate ContextWorker · budget + scope enforcement worker("commerce.guard", (req) => { if (req.amount > 10000) return tc.requireHITL(req); // FIDO2 approver if (!tc.scope(req).has("travel:book")) return deny("scope-violation"); return tc.rewrite(req, { preferRail: "tap" }); });
RelayOne is where enterprise agent traffic terminates. TrueCom receipts become the financial exhibits in its audit reports — paired with the routing and policy record RelayOne already collects. Sovereignty tags travel with the receipt, so settlement stays within the agreed jurisdiction.
// RelayOne audit export · receipts + routing in one row relayone.export({ window: "2025-Q1", include: ["routing", "policy", "tc.receipts"], format: "board-evidence", filter: r => r.tc.sovereignty === "EU-only" });
TrueCom sits between the traffic layer (RelayOne / RelayGate) and the runtime layer (R1 / Heroa). Every agent egress that touches money flows through the same receipt surface, regardless of which product invoked it.
The research preview is free for the first 10,000 transactions. No sales call. No "book a demo." Drop the SDK in, spend against the sandbox rails, ship a signed receipt back to your auditor.
Managed tier for >100k tx/mo · on-prem audit anchors · talk to eng