Skip to content

x402 & Agent Payments ​

x402 is an open payment protocol built into the request itself. For us, it is the likely rail for agents buying EIPs that are still ahead of the open hardfork.

It is not part of the open server. The hosted MCP is free. Payment follows after we have usage, a stable service, and something new to sell.

The protocol can pay today. The agent experience is still being assembled.

What x402 is now ​

HTTP already had a status for payment: 402 Payment Required. x402 defines the request, payment proof, verification, settlement, and retry around it. A facilitator can verify and settle onchain without the seller running payment infrastructure.

100M+

Payments reported by x402 since May 2025

V2

Modular protocol, MCP support, discovery extensions

50+

Organizations in the Linux Foundation x402 Foundation

HTTP-native

Quote, authorize, retry. No subscription account in the critical path.

Crypto-native

Stablecoin settlement fits users already working with Ethereum and Base.

Open rail

A protocol and facilitator interface, rather than one proprietary checkout.

That makes it a natural fit, not an automatic choice. We still need to prove the demand, the price, and the wallet path.

Primary references: x402 V2, x402 Foundation, protocol documentation.

Why it fits this product ​

PropertyFitQuestion still open
Pay per callA fixed USDC amount per tool, known before the runWhether two and four cents hold once people use it
No account requiredAgents can buy one capability without a SaaS signupWhat receipt and support path replaces an account history?
StablecoinsOur early users already understand wallets and BaseHow much wallet setup will they tolerate?
Machine-readable quoteThe buyer can decide before EthereumJS runsWhich facts must every quote expose?
Open ecosystemWallets, facilitators, and sellers can evolve separatelyWhich providers are reliable enough for production?

The product remains the deterministic run. x402 is the access rail. Pricing owns the free-to-paid cycle; token utility owns any later holder discount.

The integration gap ​

x402 V2 already has MCP wrappers, buyer spend controls, lifecycle hooks, discovery through Bazaar, and signed offers and receipts. Coinbase ships a separate Agentic Wallet MCP with funding and human-set limits. Open-source wallet MCPs can also be added to Cursor and Claude.

What does not exist yet is one native wallet contract shared by Cursor, Claude, and every other harness.

LayerStateConsequence for us
Seller protocolUsable nowWe can build standards-first on x402 V2
SettlementHosted facilitators existKeep the facilitator replaceable
WalletWorking companion MCPs existDocument paths; do not build custody
HarnessWallets are add-ons, not a native universal slotExpect setup, funding, and policy friction
MCP authorizationOAuth protects access; it does not provide paymentKeep authentication and payment separate
Autonomous policySpend caps and hooks exist in codeNever rely on a model prompt to protect funds

Strategy: merchant-ready, wallet-agnostic

Build the seller side once. Test against more than one buyer. Publish a known-good bridge for Cursor and Claude, while keeping payment logic out of the model and out of our engine.

What we do not build

No first-party wallet, custody, onramp, or facilitator. Those layers move faster than the simulation service and carry a different security burden.

Integration references: x402 with MCP, buyer spend controls, Coinbase Agentic Wallet MCP, MCP authorization.

Use the early audience ​

Our likely design partners are unusually technical and crypto-native: protocol engineers, auditors, wallet teams, agent builders. The setup cost can become part of the offer.

Frontier access

Use a new EIP before it joins the open hardfork.

Adoption lab

Try the payment path, report friction, and shape the standard in practice.

Visible evidence

Publish the quote, receipt, run provenance, and failure mode.

Design partners

Small direct cohort before broad paid access.

The message is not “pay because x402 is exciting.” It is: get useful early protocol access, and help make agent-native payment real.

What we can offer:

  • a small paid beta around frame transactions and the EIPs after it;
  • an explicit compatibility matrix for wallets, harnesses, and facilitators;
  • short, public reports on setup time, failed payments, retries, and receipts;
  • direct feedback into quote semantics and buyer policy.

Agent-to-agent horizon ​

The goal is a buyer agent that can discover the service, judge the offer, pay within policy, run the tool, and verify what came back—without a person reading this site.

Discover

Bazaar and registry metadata describe the server, tool, schema, price model, and transport.

Decide

Code checks network, asset, amount, tool, seller, and budget before a wallet signs.

Prove

Signed offer, settlement, receipt, and run provenance form one auditable chain.

Prepare now ​

Seller contract

  • Stable server identity, tool names, schemas, and versioning
  • Quote without execution; no paid work before authorization
  • Idempotent retry and replay protection
  • Facilitator adapter rather than provider logic in the engine
  • Receipt linked to the tool call and its provenance
  • Bazaar-ready discovery metadata for the paid tools

Decide before the paid beta ​

DecisionPlausible path
Charge shapeFixed price per tool (Pricing). Exact quotes, not metered gas
Buyer policyAmount, asset, network, seller, tool, per-call and session ceilings
FailureDefine expired quote, rejected signature, settlement timeout, engine error, and retry
Delivery proofSigned offers and receipts, plus the existing run provenance
DiscountsApply outside the engine; never make the community token a prerequisite
DiscoveryBazaar first for x402; MCP registry later for general discovery

Three to five months ​

Likely: more wallet MCPs, more Bazaar-listed tools, stronger spend policy, and better receipts. Possible: harnesses expose wallet UX more directly. Uncertain: one wallet interface becomes standard across them.

Our position should work in all three cases:

  1. Seller-ready. A conforming x402 buyer can pay us.
  2. Client-agnostic. No dependency on one wallet or harness.
  3. Safe by construction. Buyer policy lives in code; retries cannot double-charge.
  4. Discoverable. Metadata is ready when registry work moves from Later.
  5. Observable. We can see quote → payment → execution → receipt without storing agent secrets.

The first milestone is not “fully autonomous commerce.” It is one external agent, using a bounded wallet, discovering and buying one useful run end to end.

Changelog ​

x402 Concept Changelog
  1. v0.82026-10-06x402 stays off the open server. The hosted MCP is free.
  2. v0.72026-10-05Charge shape aligned with Pricing: a fixed amount per tool, not metered gas.
  3. v0.62026-10-05Rebuilt around x402 maturity, the harness-wallet gap, crypto-native design partners, and the decisions needed for agent-to-agent payment.
  4. v0.52026-10-01x402 moves to the post-launch paid tier (EIP-8141 first). Launch week is the open Glamsterdam MCP.
  5. v0.42026-09-24402 quote as product surface; discovery via registries and other agents.
  6. v0.32026-09-02x402 decided for launch week (USDC on Base) — rails not hook; facilitator wiring build-in-public.
  7. v0.22026-09-02Oracle built — x402 framed as launch-week payment rails, not the product hook; MCP tools exist.
  8. v0.12026-06-30Initial outline — x402 payment flow, MCP as delivery layer, registry discovery.

A living conceptualization workspace — each section carries its own micro-changelog. Latest thinking always applies.