The Three Rails of Agent Payments — x402, L402, and MPP Explained
August 7, 2026 was a landmark day for agent payments. OSL AgentPay launched — a multi-stablecoin, multi-protocol payment infrastructure built specifically for AI agents. HKEX-listed OSL didn't pick one protocol. They support three: x402, AP2, and MPP.
That multi-protocol decision tells you something important: the agent payment layer isn't going to be one winner-take-all protocol. It's going to be multiple rails, each optimized for different use cases, with aggregators (like OSL) sitting on top.
Here's a clear breakdown of the three protocols competing to be the TCP/IP of machine money — and who actually wins where.
The HTTP 402 pattern: shared DNA
All three protocols share a common ancestor: HTTP 402 Payment Required. The idea is simple and elegant:
- An agent requests a gated API endpoint
- The server returns HTTP 402 with pricing and payment instructions in the headers
- The agent pays (on-chain, automatically)
- The server verifies the payment and delivers the resource
No API keys. No monthly subscriptions. No human in the loop. An AI agent discovers a service, pays for it, and uses it — all in milliseconds.
But the settlement layer underneath that 402 response is where the three protocols diverge.
The three rails, side by side
| Dimension | x402 | L402 | MPP |
|---|---|---|---|
| Backers | Coinbase, Visa, Mastercard, Stripe, Google, AWS, Cloudflare, Solana | Lightning Labs | Tempo, Stripe |
| Governance | Linux Foundation (open standard) | Lightning Labs (single company) | Spec stage (co-development) |
| Settlement chain | Ethereum L2s (Base, Arbitrum, Polygon) + Solana | Bitcoin Lightning Network | Bank rails, card networks, crypto |
| Currency | USDC (stablecoin) | BTC (volatile) | Multi-currency (fiat + crypto) |
| Fee model | ~$0.001 per tx (L2 gas) | ~$0.0001 per tx (Lightning) | TBD (bank/card fees apply) |
| Settlement speed | ~2 seconds (L2 confirmation) | ~1 second (Lightning) | Days (bank) to seconds (crypto) |
| Scale (Aug 2026) | 200M+ txs, $50M+ volume, 480K+ agents | Early stage, site launched July 2026 | Spec only, no live transactions |
| Stable value? | ✅ Yes (USDC) | ❌ No (BTC) | ✅ Yes (fiat-native) |
| Bank integration? | Via on/off-ramps | Via on/off-ramps | ✅ Native |
x402: the enterprise standard
x402 is the clear market leader in adoption. Under the Linux Foundation with 40+ founding organizations — including 17 premier members: Visa, Mastercard, Stripe, Google, AWS, Cloudflare, Coinbase, American Express — it has more institutional backing than any other agent payment protocol.
Why it's winning:
- USDC stability. Agents pricing API calls don't want BTC volatility. A call that costs $0.01 today shouldn't cost $0.013 tomorrow. Stablecoins solve this.
- L2 economics. Base and Arbitrum settle in ~2 seconds for fractions of a cent. This makes micropayments (calls as cheap as $0.000001) economically viable.
- Multi-stakeholder governance. Linux Foundation governance means no single company controls the spec. This matters for enterprise adoption.
- Network effects. 200M+ transactions and 480K+ agents create a real ecosystem. Every new service and agent makes the protocol more valuable.
Where it's weaker: x402 assumes agents hold USDC on Ethereum L2s. For enterprises that want bank-rail settlement directly, or for Bitcoin-native applications, it requires bridging — which adds friction.
L402: the Bitcoin answer
Lightning Labs launched a dedicated L402 site in July 2026, positioning it as "the protocol for machine-to-machine commerce on Lightning." It's the same HTTP 402 pattern, but settlement happens over Bitcoin's Lightning Network.
The pitch:
- Lowest fees possible. Lightning transactions cost fractions of a cent — even cheaper than L2 gas.
- Bitcoin's security model. For applications that already use Bitcoin, L402 avoids introducing a new asset.
- Instant settlement. Lightning payments are effectively instant (no block confirmation wait).
The challenge: BTC volatility makes API pricing harder. A service priced at 100 sats today might be worth $0.03 or $0.05 tomorrow. For stable, predictable API pricing — the kind agents need for budgeting — this is a real problem.
L402 also lacks the multi-stakeholder governance of x402. It's a Lightning Labs product, not an open standard under a foundation. That may limit enterprise adoption.
MPP: the tradfi bridge
The Machine Payments Protocol (MPP), co-developed by Tempo and Stripe, is the newest and least mature of the three. It's still at the specification stage — no live transactions yet.
What makes it different: MPP is designed to span all payment rails — bank transfers, card networks, and crypto — in a single protocol. The thesis is that agents will need to pay across multiple settlement systems, and a protocol that only covers crypto is incomplete.
The pitch:
- Fiat-native. An enterprise agent can pay from a bank account without converting to crypto first.
- Stripe distribution. If Stripe builds MPP into its existing merchant network, millions of businesses could accept agent payments overnight.
- No new asset required. Agents pay in whatever currency the merchant accepts — USD, EUR, USDC, whatever.
The challenge: MPP doesn't exist yet. It's a spec, not a running network. And spanning bank + card + crypto means inheriting the worst properties of each: bank settlement takes days, card networks charge 2-3%, and crypto requires wallet management. The abstraction layer that hides all this complexity from agents is the hard part — and it hasn't been built.
OSL AgentPay: the aggregator thesis
This is what makes OSL AgentPay's August 7 launch significant. They didn't pick sides. Their platform supports x402, AP2, and MPP simultaneously — with USDT, USDC, USDGO, and more.
The aggregator pattern: OSL sits above the protocol layer. An agent developer integrates with OSL once, and OSL handles routing payments across whichever rail makes sense — lowest fee, fastest settlement, or whatever the merchant requires.
This is a pattern we've seen before. Plaid aggregates bank APIs. Stripe aggregates payment methods. Twilio aggregates carrier networks. The protocol that "wins" isn't the one that kills the others — it's the one with the best aggregation layer on top.
Who wins where?
The most likely outcome isn't one protocol dominating. It's protocol specialization by use case:
| Use case | Best rail | Why |
|---|---|---|
| AI agent calling APIs (micro-payments) | x402 | Stable value (USDC), low fees, production scale |
| Bitcoin-native apps (Lightning wallets, Nostr) | L402 | No new asset, Bitcoin security model |
| Enterprise procurement (agent buys SaaS) | MPP | Bank-rail settlement, existing Stripe merchants |
| Multi-currency, multi-protocol | Aggregator (OSL AgentPay) | Route to best rail per transaction |
What this means for agent developers
If you're building an agent that needs to pay for services today, x402 is the only production-ready option at scale. It has the most services, the most agents, the most institutional backing, and the most mature tooling.
But the landscape is shifting fast. L402 gives Bitcoin-native applications a path to agent payments without leaving the Lightning ecosystem. MPP, when it ships, could bring Stripe's entire merchant network into the agent economy.
The smart move for developers: build on x402 now, design for multi-rail later. The protocols share the same HTTP 402 pattern — the payment header format is the abstraction layer. An agent that speaks x402 today will need minimal changes to speak L402 or MPP tomorrow, because the pattern is the same even when the settlement rail changes.
The real story: this is happening fast
Three months ago, x402 was the only game in town. Now we have:
- A Linux Foundation-governed standard with 40+ organizations and 200M+ transactions
- A Bitcoin-native alternative from the team that built Lightning
- A Stripe-backed protocol aiming to bridge crypto and traditional finance
- A publicly-listed aggregator (OSL, HKEX:863) shipping multi-protocol support
The agent payment infrastructure layer is forming in real time. The HTTP 402 pattern — dormant for 27 years — is suddenly the most interesting spec in internet infrastructure.
Appendix: quick protocol reference
x402 — HTTP 402 with USDC settlement on Ethereum L2s. Linux Foundation governance. Production scale (200M+ txs). Website: x402.org
L402 — HTTP 402 with BTC settlement on Lightning. Lightning Labs product. Early stage. Site launched July 2026.
MPP — Machine Payments Protocol. Multi-rail (bank + card + crypto). Tempo + Stripe. Spec stage, not live.
OSL AgentPay — Multi-protocol aggregator (x402, AP2, MPP). Multi-stablecoin (USDT, USDC, USDGO). Launched August 7, 2026. HKEX:863.