How software pays for things.

A ten-minute walkthrough of the two open protocols that let an AI agent pay for what it uses, per request, with no account. Nothing here is a mock: on slide 4 you will watch a real payment request happen on this server.

Presenter: → / ← to move, N for your speaker notes, P to print the deck as one page.

An AI agent cannot sign up for anything.

Send a software agent to do a real job and it constantly needs things it does not have: a live web page, a filing, a conversion, a piece of data. Every one of those sits behind a signup, an API key, a credit card, or a terms-of-service checkbox.

A person clicks through that in a minute. A program cannot: it has no inbox to confirm, no card, no authority to accept terms, and no way to keep twenty keys safe.

The web already had a button for this: 402 Payment Required.

When the web's rules were written in 1997, the authors reserved a response code for "this costs money" and never used it, because card payments could not fit inside a single web request. Stablecoins changed that: a payment can now be a small signed message that travels inside the request itself.

Two open protocols do exactly this: x402 (started by Coinbase) and MPP, the Machine Payments Protocol (started by Tempo, on a standards track). Same idea, two dialects of the same handshake.

A real request, right now.

Ask. Pay. Get. Three steps, a couple of seconds.

1. Ask. The agent makes an ordinary web request. The server answers 402 and, in the headers, quotes a price: which currency, which chain, which address, how much, valid until when.
2. Pay. The agent's wallet signs a permission slip for exactly that amount ("move $0.001 from me to them, valid for five minutes") and repeats the same request with the slip attached. The key never leaves the agent, and it pays no network fee.
3. Get. The server checks the slip, does the work, moves the money on chain, and returns the answer with a receipt that ties this payment to this response.

x402 and MPP: same handshake, different headers.

Agent402 answers both on the same 402 at the same price. The buyer's software picks the dialect; the seller does not have to choose.

Dollars on a public ledger, and receipts anyone can check.

Stablecoins are dollars that live on a public ledger: USDC is one dollar, always. Payments here are USDC (or USDG on Robinhood Chain), so nobody prices anything in a volatile token.

Twelve rails. A buyer pays on whichever chain their wallet already uses; the 402 lists them all at one price. On the EVM chains the buyer pays no network fee at all.

Every payment is a public record. That is what makes this an economy rather than a wire: sellers can be ranked by settlements the chain actually shows, revenue can be published with proof, and a router can refuse to send money to a seller nobody has ever paid.

Live revenue with every figure linked to its receipt →

Most of the ecosystem ships the protocol. Agent402 ships the market that runs on it.

Agentic finance: agents that pay and get paid on their own.

Once the plumbing works, a market forms on top of it: price discovery, routing between competing sellers, reliability signals, receipts, transparent revenue. Software agents become customers and, just as quickly, vendors.

The practical test for any of it: could the software complete the purchase with no human awake? If a human has to approve, register or paste a key, it is not agentic.

The definition and the stack → Every term, defined once →

Ten minutes in, you have seen a real one. Here is how to try it yourself.

Questions to leave them with: which of your endpoints would an agent pay for today? And what would your agent buy if it could?