x402 vs MPP: Neither Solves Execution.
The machine economy needs a way to pay for things. Not humans tapping "confirm" on a checkout page. Machines. AI agents buying compute, querying data feeds, calling APIs, and settling the bill without a human in the loop.
Two protocols shipped within months of each other to solve this. Coinbase's x402 revives the long-dormant HTTP 402 status code to make payment a native part of the web request cycle. Stripe and Tempo's Machine Payments Protocol (MPP), which went live on March 18, takes a different approach: sessions, streaming payments, and multi-rail settlement designed for high-frequency agent transactions.
Both are serious efforts. Both have real backing. And if you're building on-chain automation, both will affect how your infrastructure handles money.
x402: Payment as a Response
x402 is elegant in its simplicity. A client requests a resource. The server responds with HTTP 402 and a PAYMENT-REQUIRED header specifying the price, token, and chain. The client pays, attaches proof via a PAYMENT-SIGNATURE header, and retries. The server verifies, settles, and delivers.
No accounts. No API keys. No invoices. Just pay and access.
The protocol separates concerns across three roles: the client (the agent paying), the resource server (the service), and the facilitator (the server handling payment verification and on-chain settlement). Any HTTP server can become a paid endpoint by adding a few lines of middleware, with SDKs available in TypeScript, Python, Go, and Java.
Where x402 gets interesting is the Bazaar: a machine-readable discovery layer that lets agents find, evaluate, and pay for services automatically. Servers declare their capabilities, pricing, and schemas. Agents query the Bazaar, then transact directly via 402 responses. Combined with SIWx for wallet-based authentication, this creates a composable marketplace where agents autonomously discover and consume paid services.
The numbers so far: roughly 75 million transactions processed, $24 million in volume, about 94,000 buyers. But CoinDesk's analysis suggests daily volume averages around $28,000, with a meaningful share coming from testing rather than production commerce. The protocol works. Organic demand is still catching up.
MPP: Payment as a System
MPP takes a fundamentally different approach. Where x402 treats each request as an independent payment event, MPP introduces sessions: an agent opens a payment channel, locks funds into an escrow contract with a spending cap, and issues signed vouchers off-chain as it consumes services. Thousands of micro-payments aggregate into periodic on-chain settlements.
The result is sub-100ms latency per payment, near-zero per-request fees, and true pay-as-you-go economics at scale. For agents making hundreds of API calls during a single task, this is a structural advantage over one-transaction-per-request models.
MPP's other differentiator is rail agnosticism. The protocol runs natively on Tempo (a payments-optimized L1 with 10,000+ TPS and sub-second finality), but Stripe has extended it to cards and wallets, Visa to card-based payments, and Lightspark to Bitcoin Lightning. An agent can pay in USDC on Tempo or settle through a traditional card rail. This multi-rail design means MPP doesn't force the machine economy into crypto-only settlement.
The Stripe integration is the strategic play. MPP transactions appear in the Stripe Dashboard like any other payment. Fraud protection, tax calculation, reporting, and refunds come out of the box. At launch, the payments directory already includes over 100 services (Alchemy, Dune, Anthropic, OpenAI, DoorDash, Shopify) with Mastercard and Visa as partners.
Where They Actually Differ
Settlement. x402 settles on-chain per request across Base, Polygon, and Solana. MPP batches off-chain vouchers into periodic settlements on Tempo, with optional fiat settlement through Stripe.
Payment rails. x402 is crypto-native: stablecoins on supported chains. MPP is multi-rail: stablecoins, cards, wallets, Lightning.
Agent workflow fit. x402 is ideal for one-shot, permissionless access. MPP is built for sustained, high-frequency consumption where an agent opens a session, streams hundreds of payments, then settles once.
Neutrality. x402 is governed by an independent foundation (Coinbase and Cloudflare co-founded it). MPP is co-authored by Stripe and Tempo: open-source, but optimized for their stack.
x402 is "payment as a response." MPP is "payment as a system." They're solving different shapes of the same problem.
The Piece Nobody's Talking About: Execution Infrastructure
Here's where the conversation usually stops: which payment protocol should you adopt? But for anyone running on-chain operations, that's the wrong question to fixate on.
An AI agent can have the most elegant payment session in the world. It can discover services via the Bazaar, open MPP sessions with perfect spending caps, and settle in sub-100ms. None of that matters if the on-chain transaction it's trying to execute fails because gas spiked 10x during a congestion event, or the transaction gets stuck in a pending state, or the retry logic doesn't exist.
Payment protocols handle how money moves between agents and services. Execution infrastructure handles what happens after the agent decides to act on-chain. That's where the real reliability challenge lives: transaction retry logic with exponential backoff, smart gas estimation that adapts to network conditions in real time, transaction simulation before execution, and audit trails that track every action.
At KeeperHub, this is the layer we're building. The wallet is just the signing mechanism. The execution infrastructure around it, including full audit trails so every action is logged, traceable, and auditable, is what keeps transactions from wasting gas or getting stuck during the exact moments that matter most.
As these payment protocols mature, agents using them will increasingly need to act on-chain, not just pay for off-chain services. Rebalancing a DeFi position after an AI model flags risk. Executing a liquidation before the window closes. Moving funds across protocols based on yield signals. These are operations where reliable execution isn't optional; it's the entire point.
The emerging stack: x402 or MPP handles how the agent pays for intelligence. A reliable execution layer handles how it acts on that intelligence on-chain. Both need to work. Neither is sufficient alone.
What to Watch
McKinsey estimates that by 2030, AI agents could mediate $3 to $5 trillion in transactions globally, characterized by smaller, faster, and more frequent payments.
x402 covers the long tail: open, permissionless, crypto-native services where any agent can pay any server without pre-negotiation. MPP covers enterprise traffic: high-frequency, compliance-ready, multi-rail transactions backed by Stripe's distribution. They're not competitors. They're different layers of the same stack.
The teams building on-chain automation should be watching both. And they should be asking the harder question: once the agent has paid for its intelligence, what's the execution infrastructure that lets it act on it reliably?
That's the part that determines whether the transaction actually lands.
