Unchained Podcast Summary

Episode: How the X402 Standard Is Enabling AI Agents to Pay Each Other

Host: Laura Shin
Guests: Eric Reppel (Head of Engineering, Coinbase Developer Platform & Author of X402), Sam Ragsdale (Founder & CEO, Merit System)
Date: November 15, 2025
Episode #: 948

Main Theme

This episode unveils the transformative potential of X402, a new open protocol and standard that enables seamless, internet-native, machine-to-machine (M2M) payments—particularly for AI agents. The conversation explores the history behind status code 402, the architecture and design principles of X402, and the way it unlocks new models of agentic commerce (AI agents autonomously buying services or data for humans). Laura, Eric, and Sam discuss both the technical underpinnings and the future implications for digital commerce, developer experience, and real-world apps.

Key Discussion Points & Insights

1. Background: Why X402 and Why Now? (04:00 – 08:55)

• Internet standards like HTTP, HTML, CSS enabled interoperability for data but nothing similar ever emerged for native value transfer.
• Status Code 402 ("Payment Required") was reserved back in the ’90s by web pioneers for this purpose but was never implemented due to limitations around microtransactions and lack of digital currency.
• AI agents (LLMs and bots) are now pressing the issue, as they need reliable, automated, and fine-grained payments to interact and cooperate online.
• Eric Reppel: “AI is really the incumbent force where we should actually take this problem seriously and try to solve it.” (01:49)

2. What Is X402? How Was it Started? (06:28 – 08:55)

• Eric researched historic payment attempts and realized stablecoins + programmable blockchains finally made internet-native, composable payments possible.
• Collaboration with Coinbase and launch at ETHDenver, with a foundational focus on making X402 open, multichain, and neutral—not a vendor lock-in for Coinbase.
• X402: A standard for “declaring payments”—not custodying funds or enforcing payment. Offers a consistent method for creating, presenting, and fulfilling payment requests on the web.
• “Stablecoins and modern blockchains just are the best way to move money that exists on the planet right now ... it’s the only real way to move a tenth of a cent...” — Eric Reppel (06:38)

3. How Does X402 Differ From Existing Online Payments? (08:55 – 12:44)

• Today’s payment forms (credit card inputs, etc.) look universal at the UI level but are entirely bespoke on the backend—every integration is different.
• X402 Standardizes the Server-to-Server Flow: For AI agents, automation, and integration is critical: credit card UIs are not machine-friendly; X402 creates a deterministic API for value transfer.
• No chargebacks, self-custodial, and developer-centric: Simpler dev experience, fewer legal entanglements, and true microtransaction support.
• Sam Ragsdale: “The devex [developer experience] is just fundamentally better ... less work to integrate, no chargebacks, much easier to send and receive money.” (10:56)

4. Technical Design: Chain-Agnostic, Like ERC20 for Payments (12:44 – 16:39)

• How X402 Works: Specifies how each blockchain should handle payments (e.g., EIPs for EVM chains, SPL for Solana), but doesn’t require custom code per chain. Each blockchain’s community can adopt its best practices under the X402 umbrella.
• It’s a Standard, Not a Protocol: “A standard is an agreement… but you can't actually enforce it. It’s just that if you don’t follow the standard, you lose the network effects and the ecosystem compatibility … things just break.” — Eric Reppel (16:39)

5. Sam Ragsdale’s Perspective and Projects (17:29 – 20:49)

• Merit Systems' Focus: Developer monetization, AI payments, and discoverability in the X402 ecosystem.
• Tools built: X402 Scan (like Etherscan for payments/resources), and Composer (an agentic interface to interact and compose with payment-enabled APIs).
• Composable Commerce: Agents can bundle several content/data/API purchases across multiple parties—e.g., a vacation-planning AI agent making several small purchases automatically.

6. The User Experience Vision: Invisible Infrastructure (21:10 – 23:15)

• End-Users Won’t See X402: Real success is when “people don’t think about X402 at all.” Agents can make hundreds of small payments in the background to optimize your services—think: buying detailed weather data for your ski trip planning agent.
• Custom AI-Paid Content: Example includes paying per news article, with an agent assembling your tailored daily news briefing.

“You may only want to go to Alberta when there's fresh snow. So your AI agent may pay 10 cents to get a super accurate weather forecast...and then recommend, hey, you should go on these dates.”—Eric Reppel (21:42)

7. Merchant/Business Onboarding and Open Adoption Model (25:32 – 28:10)

• Very low friction integration: Often “under an hour” for businesses to support X402, using existing wallets or accounts.
• No gatekeepers: Anyone can accept payments; no legal agreements or onboarding forms required (unlike traditional processors).

8. Competition, Governance, and The X402 Foundation (28:10 – 29:59)

• Some initial forks/competing standards, mostly due to concerns X402 would be Coinbase-exclusive—but strong efforts underway for neutral, multi-company governance.
• Coinbase and Cloudflare are founding members of the new X402 Foundation, signaling ecosystem trust and broad adoption.
• Integration Example: Cloudflare will let website owners accept pay-per-crawl payments through X402.

9. Where X402 Wins First: Agentic Commerce and Beyond (30:40 – 33:03)

• Immediate fit: Small, frequent, autonomous agent payments—e.g., buying API data, paying for compute, etc.—where old payment rails can't reach.
• Long term: Could be co-adopted with fiat/credit rails; X402 is payment-method-agnostic and could facilitate both crypto and fiat payments in a standardized way.

10. Fees, Gas, and Chargebacks (36:17 – 44:44)

• No protocol fees: X402 itself doesn’t mandate a fee; only network costs (e.g., gas) or any third-party facilitator costs apply.
• No built-in chargebacks: More akin to cash—not easily reversed. Opens up the need for new schemes (within the standard) to support refunds, reputation, and consumer protections, possibly as new modules/extensions to the base protocol.

“I think it's fundamentally better to have a system that does not have chargebacks … you go to the merchant … and if they don't give you your $10 back, then they're a bad merchant and you'll go and tell everybody… you can actually just have an economy that runs on merchant reputation.” — Sam Ragsdale (41:41)

• Multiple Payment Methods: Merchants can present options—fiat and stablecoin—per transaction, with different tradeoffs (e.g., chargeback on Visa, discount with USDC).

11. Integrations with Other Protocols & Discoverability (45:12 – 47:12)

• Payments MCP: A Coinbase bridge, enabling LLM agents like Claude to hold wallets and directly pay for APIs/data/tasks using stablecoins via X402.
• Google A2A: A protocol for agent-to-agent communication, with X402 as the payments rail.
• Developer Tooling: Robust, easy-to-integrate SDKs and scanning/browsing tools accelerating innovation.

12. Real-World Use-Cases and Ecosystem Growth (47:32 – 52:23)

• Explosive Growth: 20 million transactions in the past month, with ~13 million USD transacted—much of it (currently) meme coin-related, but increasingly, high-value/utility developer APIs.
• Composable APIs: “You don’t need to create a direct relationship with every single buyer … you get really good composability of the different resources.” — Eric Reppel (51:06)
• Novel Services: Example: auto-generating and mailing a T-shirt based on current news, all composed from various API calls and services paid via X402.

13. Reputation and Security in Agentic Commerce (52:27 – 54:34)

• Spam/Scam Mitigation: Discovery, review, and reputation are critical—the community is developing standards like EIP8004 (reputation systems) to address trust.
• The Need for More Standards: Rich, safe agentic commerce will require many standards (for payments, identity, reputation, etc.), evolving like the web did (HTTP, HTML, CSS, search/PageRank).

Notable Quotes & Memorable Moments

• “This is just a problem that's existed for a long time and it's an idea whose time has come. AI is really the incumbent force where we should actually take this problem seriously and try to solve it.” — Eric Reppel [01:49]
• “Having built on X402 quite a bit ... the devex is just fundamentally better.” — Sam Ragsdale [01:59]
• “We typically see companies being able to add X402 ... in under an hour. It’s really as simple as one line of code and then having a wallet...” — Eric Reppel [25:49]
• “You don’t need to ask anybody’s permission to accept checkout ... that’s fundamentally better about crypto than the existing payment rails.” — Sam Ragsdale [27:11]
• “The dream is ... you could have a bunch of different servers that offer different resources and you can use an AI agent on top of it to compose a single end request.” — Sam Ragsdale [17:29]
• “As chains continue to get more and more efficient and cheaper ... you’re just paying the root costs of the transfer.” — Eric Reppel [37:59]
• “At some point we are going to need to handle the chargeback problem ... But those are very difficult problems that you need to progressively build up to.” — Eric Reppel [39:51]
• “I actually think you totally can have an economy that works without chargebacks ... you can actually just have an economy that runs on merchant reputation.” — Sam Ragsdale [41:41]

Key Timestamps for Important Segments

| Timestamp | Segment/Content | |-------------|-------------------------------------------------------------------------------------------------| | 04:00 | Why payments on the internet were never standardized; the 402 status code historical context | | 06:38 | Eric’s story about reviving the idea and standardizing X402 | | 08:55 | Difference between X402 and mainstream online payments | | 10:56 | Sam’s developer perspective: devex, chargebacks, and integration | | 12:59 | How X402 is chain-agnostic; differences from prior standards | | 16:39 | Standards vs. protocols: nuances in blockchain adoption | | 17:29 | Sam’s entrypoint and tool-building in the X402 ecosystem | | 21:42 | User experience vision: AI agents making seamless microtransactions | | 25:32 | Merchant adoption, open integration, CDP tools | | 28:10 | Competing standards and evolution toward X402 Foundation | | 30:40 | Where X402 fits best: agentic commerce, future coexistence with fiat | | 36:17 | Fees/gas – why X402 itself does not charge any additional fees | | 39:51 | Chargebacks, reputation and handling refunds without intermediaries | | 45:12 | Integration: Payments MCP and Google A2A | | 47:32 | Real-world and emerging X402 apps and composable API services | | 52:27 | Preventing spam/flaky agents: reputation, EIP8004, discovery mechanisms | | 54:34 | The analogy to standards layering on the Internet, search, and overall ecosystem development |

Language & Tone

• Candid, pragmatic, and clearly focused on technical practicality—frequently referencing “devex,” composability, and real-world usability.
• Enthusiastic about open standards, and their parallels in internet history.
• Pragmatic acknowledgment of current limitations (e.g., chargebacks, gas, reputation), with an incremental approach to expanding capabilities.

Conclusion

This episode is an essential primer on why and how “agentic commerce” (AI agents paying each other) is becoming technically and economically feasible for the first time, thanks to X402. The guests frame X402 as a foundational standard like HTML or HTTP, unlocking whole new classes of digital commerce, tools, and developer composability that were previously out of reach. The discussion illuminates both the strengths (open, frictionless, microtransaction-friendly, chain-neutral, permissionless) and current challenges (refund mechanics, spam, merchant/user discovery) facing the space. A must-listen for anyone interested in the future of internet payments, autonomous agents, and composable Web3.