Recourse.
The trust layer for autonomous money
checking… mode: — ◉ Live — real on-chain Score Network Operator Console → Dispute Console → ▶ Run the Live Demo
Infrastructure · API for AI-agent & stablecoin payments

When software spends money on its own,
there's no way to undo a bad payment.

Stablecoin and AI-agent payments are irreversible — once sent, the money is gone. No chargeback, no dispute, no escrow. In July 2026 the industry standardized how agents pay: the x402 Foundation launched under the Linux Foundation with Visa, Mastercard, Stripe, Circle, Coinbase and Google at the table — and its charter says nothing about what happens when a payment goes wrong. Visa and Mastercard add chargebacks only when a card stays in the loop. Recourse is the recourse layer for the payments that are truly card-free — agent-to-agent, x402, on-chain, peer-to-peer. We don't move the money; we make it safe to move.

109 passing tests x402-native · 402 challenge, verify & wrap live Settles in USDC on Base Plugs under x402 / AP2 / ACP Audited-style escrow
Products · one API, four primitives

The trust layer, as building blocks.

Everything an autonomous agent needs to move money safely — exposed as a clean API and a 5-line SDK. Use one primitive or all four.

🔒

Escrow

Hold a payment in an audited smart contract instead of sending it. Conditional release on delivery, timeout, or dispute.

POST /v1/payments
⚖️

Disputes

When a deal goes bad, three AI judges — compliance, forensics, network graph — rule in seconds. Low-confidence cases escalate to a human arbiter who co-signs. eBay's 90%-automated playbook, for agents.

/dispute · /pof/validate
📊

The Recourse Score

A Bayesian trust score for every counterparty, built from every dispute across the network. A credit score for autonomous commerce.

GET /v1/reputation
🛡️

Policy & Underwriting

The score becomes an enforced action: block, escrow, or instant-guaranteed settlement — priced by risk, two-sided.

/v1/policy/evaluate
Solutions · by use case

Built for software that spends money on its own.

🛒

AI shopping & procurement agents

Agents buying goods, data, or services for a user or business — protected from a wrong or fraudulent purchase.

🏪

Agent marketplaces & platforms

Embed Recourse as your platform's trust layer — every agent on it inherits recourse, instantly.

🔌

API / data / compute sellers (x402)

Monetize agents via pay-per-call without fearing non-payment or fraud on irreversible micropayments.

💸

AI-native finance, payroll & treasury

Higher-ticket autonomous payouts where a single bad transaction is expensive — gated, priced, and recoverable.

Who uses Recourse

AI-agent companies call our API instead of paying directly.

Our customer is the developer building an autonomous agent — shopping, procurement, data/API buying. Their agent moves real money with no human watching. Five lines change that.

Today — money gone if it goes wrong:
payVendor(vendor, 50_USDC)   // irreversible. no recourse.
Add recourse in 5 lines — escrowed, disputable, scored:
npm install @recourse/sdk

const recourse = new Recourse({ apiKey })

// pay through escrow instead of sending money you can't get back
const p = await recourse.pay({ to: vendor, amount: "50" })
await recourse.dispute(p.id)              // bad delivery → refund
const { score, decision } = await recourse.check(vendor, "50")
Typed SDK · contract independently auditable on request.

The demo below = this agent's experience

The run below is exactly what happens inside that developer's agent — simulated so you can watch it. In production a human never sees it; it runs thousands of times a day inside other companies' software. You are the invisible layer underneath.

We ship as an x402 facilitator AP2 / ACP compatible so we plug under existing rails — "keep your rail, add recourse."

How you plug in

Two ways to plug in.

In every case the customer is the team building the agent — they integrate once and pay the take rate; the end-user is the one protected.

1 · Direct — the SDK

npm install @recourse/sdk → wrap any agent payment in ~5 lines. The agent calls us directly: pay(), dispute(), check(). Fastest path, full control.

2 · Under the rails — x402-native, live today

Our API speaks x402 end-to-end: a spec-compliant 402 challenge on our own endpoints, facilitator-grade POST /v1/x402/verify (EIP-3009 signature verification), and POST /v1/x402/wrap — one call that adds escrow + dispute rights to any seller's x402 payment. Every payment verified through us mints a dispute-rights receipt wired into the dispute engine. "Keep your rail, add recourse" — minimal change.

On partnerships: we're compatible with the open standards the ecosystem is adopting (x402, AP2/ACP) — that's how we plug in without anyone's permission. Formal partnerships (e.g. a recommended-facilitator listing) are a go-to-market goal on the roadmap, not a current claim.

Live demo

Watch an AI agent get scammed — and recover. Then watch the network learn.

Run a payment. The escrow holds, the agent disputes a bad delivery, and a panel of three AI judges rules in seconds — escalating to a human arbiter who co-signs when confidence is low. The agent is refunded, and the outcome updates The Recourse Score, which every other agent on the network now inherits.

$0
Protected volume (TPV)
$0
Revenue earned (~0.8% take)
0
Payments
0%
Refund rate
0
Vendors scored

The demo has its own console.

Run a live payment through the real API: escrow, an AI-agent dispute, a panel of three AI judges you can click into and interrogate, human escalation when confidence is low, and the score updating in real time.

▶ Open the Live Demo
Runs against the live Recourse API · every ruling hashed as precedent

The Recourse network — every agent's disputes build one shared trust graph (illustrative demo data)

VendorRecourse ScoreDeliveriesLost disputesPolicy for next $50 payment

🔄 Why a brand-new agent wins on day one — the moat.

A first-time agent has zero history of its own. On its own it would have to get scammed once to learn a vendor is bad. The moment it joins Recourse, it inherits the entire network's dispute history — it avoids losses it did nothing to earn the knowledge of. Every agent's bad experience protects every other agent. A competitor can copy our code in a weekend; they cannot copy this shared graph.

Why this is a company, not a feature

The Recourse Score is the moat.

Anyone can ship an escrow contract. The defensible asset is The Recourse Score — a credit score for autonomous commerce, built from every dispute outcome across the network (above). It only works if you're neutral across rails, which Stripe / Circle / Coinbase structurally can't be — they each own a rail. That's exactly why Visa, sitting between issuer and acquirer, is the trust layer — not the banks.

And the score is already a product with a price: the basic score is free (the funnel), while machines pay $0.01 per premium trust report — over x402, today — and the score's real power is that it's enforced: it gates every payment, sets the protection fee, and decides who qualifies for guaranteed instant settlement. See the live Score Network — 50 counterparties, updating in real time →

We don't charge for escrow. We charge for risk borne.

Escrow is a smart contract — near-free, so we price it that way. The fee scales with the loss we prevent, not the money we hold. And the loss is large: a bad payment is a 100% loss, a card chargeback costs a merchant up to 3.4× the transaction, and businesses lose ~$4.60 per $1 of fraud. Against that, 0.6–1.5% to make a payment recoverable is cheap — and it's below Escrow.com (0.9–3.25%) and card interchange (~1.8%).

Two-sided revenue, like a card network. The agent (payer) pays a protection fee for escrow + dispute + refund. The vendor (payee) pays an instant-settlement fee when they opt to be paid now and we front + guarantee it — factoring their receivable. Whoever gets the benefit pays.

Agent: protection

Escrow + dispute + refund. Scales with vendor risk (150 → 100 → 60 → 40 bps); cheapest when the vendor is trusted.

Vendor: instant settlement

Opt to be paid now instead of waiting out escrow — we front & guarantee it (~60 bps). Liquidity, so the vendor pays. Trusted vendors only.

Underwriting spread

In the instant tier we absorb the dispute risk — insurance economics, priced off the Recourse Score.

Comps: Escrow.com 0.89–3.25% · card interchange ~1.81% avg · chargeback all-in cost ~3.4× face · $3.75–$4.61 lost per $1 of fraud (2025).

Where this goes

From working demo to the default trust layer.

Now0–3 mo3–9 mo9–18 mo
✓ SHIPPEDNowWorking product
x402-native API — machines pay per call, liveAI dispute panel + human escalationLive Score Network (50 counterparties)7-gate preflight on real Base mainnet109 tests · USDC on Base
SCALE3–9 monthsMainnet + real volume
Non-custodial stablecoin escrowFirst real protected volumeReputation data compoundsPricing & gating turn on
MOAT9–18 monthsUnderwriting at scale
Guaranteed settlement — high-marginCapital reserve + actuarial modelExpand corridors & railsCross-rail APP-fraud recall

Next up: design partners + a third-party audit — the ~18–24 month window to own the trust-data flywheel before it consolidates.

Full roadmap, costs & use-of-funds in the deck.

Recourse · the trust layer for autonomous money  ·  settles in USDC on Base  ·  code