Agentic x402, A to Z

Key Takeaways

• AI agents are evolving from tools into economic actors. They are no longer simple automation bots but autonomous software that independently judges, executes, and pays. Gartner projects that by 2028, over $15 trillion in purchasing activity will be generated or influenced by AI agents.

• The existing financial system is structurally incompatible with the agentic economy. KYC requires a human face. Subscriptions assume monthly billing cycles. UIs assume someone is clicking buttons. Agents need micropayments, programmatic access, and 24/7 availability. x402 tries to solve this by embedding stablecoin payments directly into HTTP.

• x402 is an internet-native payment standard that enables instant stablecoin settlement on top of the HTTP protocol. Led by Coinbase, major tech players including Cloudflare, Stripe, and Vercel are participating in its integration. An ecosystem composed of six layers—Agent, Interface, Protocol, Trust, Facilitator, and Blockchain—is rapidly expanding.

• Fraudulent transaction rates dropped from 90% to below 10%, but a killer app is still absent. Real transactions peaked in December 2025 (daily average of 1.43 million) before declining to 180k in February. The plumbing is in place, but a core application that drives sustained demand must emerge for mainstream adoption to follow.

• x402 is evolving into a universal protocol, not the exclusive domain of any single chain. From Base's initial 100% monopoly, Solana has overtaken it with 82% of real transactions, while Polygon(@0xPolygon) has grown to 11%, signaling intensifying cross-chain competition. This competition is raising technical maturity, reducing chain-lock-in risk, and spurring new infrastructure innovations to address cross-chain interoperability challenges.

• The success or failure of x402 ultimately hinges on the completeness of the 'trust layer.' In exchange for the speed and scalability gained by removing human judgment, computational trust based on TEEs and heuristic trust based on on-chain reputation must be reconstructed through code and cryptography. The integration of this trust stack will set the precedent for the broader infrastructure transition to an agentic economy.

1. The Importance of the Agent Economy

"Machine-native finance just went live." "Agents are becoming economic entities, not tools." "We are moving from humans paying bots to bots paying bots."

AI agents are autonomous software systems that take a user’s goal as input, make their own judgments, and execute tasks end to end. They are evolving beyond simple Q and A into true digital representatives that can handle everything from information retrieval to bookings and payments. Still, many people continue to view AI agents as simple bots that follow pre-defined rules, or they question whether agents are ultimately just scripts written by humans. From that perspective, delegating complex work entirely to agents can feel premature.

However, the rapid progress of LLMs and the emergence of open-source agent services like OpenClaw (OpenClaw, @openclaw) are quickly overturning this perception. As more real-world examples appear where agents directly operate a user’s PC or a service’s system permissions and complete actual tasks, expectations for agent scalability and the future have grown. Interest in agent technology is spreading fast across industries, to the point where a Mac mini sell-out frenzy became a talking point.

Source: Google Blog

As this interest expands, the concept of an "Agent Economy" is also gaining attention. The more complex work agents perform, the more frequently they will encounter moments that require payment. That makes it essential to build an economic ecosystem across the entire system so that the payment process does not become a bottleneck.

Big Tech companies are moving aggressively, almost as if they anticipated this future. Google is a clear example. It has been announcing standards in quick succession: the agent-to-agent communication protocol A2A (April 2025), the payment protocol AP2 (September 2025), and the commerce standard UCP (January 2026) that combines them to unify the entire shopping flow. Gartner forecasts that by 2028, more than 15 trillion dollars of purchase activity will be generated or influenced by AI agents. That is why the agent economy’s potential is not just hype.

2. x402, the Game Changer for the Agent Economy

Source: Coinbase

In May 2025, x402 was developed under Coinbase’s leadership in collaboration with multiple Big Tech companies. Positioned as internet-native payments, x402 enables instant stablecoin payments through the HTTP protocol. The goal is clear: if AI agents are to act autonomously on the internet, value flows must be handled programmatically just as seamlessly as information flows.

This is exactly what blockchains are built for. Since Ethereum launched in 2015, it has been possible to deploy code-based contracts on-chain and execute them automatically without intermediaries. Stablecoins, on-chain tokenization of traditional assets such as RWAs, prediction markets, and even meme coins share a common pattern: they remove chronic inefficiencies in legacy systems by enabling code-executed settlement, eliminating bottlenecks in money flows. That characteristic directly aligns with the payment infrastructure problem the agent economy faces.

Jeff Weinstein (@jeff_weinstein) at Stripe summarized the infrastructure requirements for agent payments succinctly when he announced x402 adoption. In response to the question "Why not just use virtual cards for agent transactions?", he explained that agents need microtransactions, 24/7 global rails, control structures that work even when humans are not involved, an HTTP-native interface, low latency, and guaranteed finality. He also pointed out that "The current financial system is tuned for humans."

That diagnosis is accurate. Existing payment systems don't work for AI agents—not because the technology is lacking, but because they were designed for a different premise entirely. When every step assumes a human will be there, agents become outsiders by default. This fundamental conflict shows up clearly in three areas.

• UI dependence: Traditional payments are optimized for humans to visually confirm and click through flows, which turns the entire process into friction for agents that communicate via APIs.

• Onboarding overhead: Account creation and KYC exist to verify human identity and establish trust. Agents have neither the authority nor a practical method to complete these processes.

• Billing unit mismatch: Monthly subscriptions or prepaid credit packages are designed for long-term human usage patterns. Agents, by contrast, tend to pay only as needed per single API call, making these models fundamentally misaligned.

When mapped against these requirements, blockchain suitability becomes obvious. On chains with optimized gas fees, cent-level microtransactions are feasible. Blockchains have no business hours and no borders, so 24/7 global rails are the default. Smart contracts can be triggered directly through HTTP calls, so there is no need to go through a UI. High-performance chains like Solana can offer fast transaction finality on the order of hundreds of milliseconds, and control logic such as spending limits and approval conditions can be embedded directly into contract code.

If the legacy financial system is tuned for humans, blockchain is infrastructure tuned for code from day one. Smart contracts(or Program in Solana) execute and settle automatically when conditions are met, independent of human approvals or operating hours. If UI dependence, onboarding overhead, and billing unit mismatch all originate from a structure that requires human intervention to function, blockchain is infrastructure designed to remove that intervention by default.

In an agent economy where even decisions happen programmatically, requiring human approval for payment creates a bottleneck. But blockchain infrastructure alone doesn't solve this. When an agent calls a web API, payment must complete inside that HTTP request-response cycle—no separate wallet connection, no manual signing. That's the gap between infrastructure and application layer. x402 is a protocol designed to close it.

3. Agent-Native x402 Stack Analysis

From an agent economy perspective, x402 has six layers across two domains.

• Application Layer: Where agents make economic decisions and initiate transactions.

• Infra Layer: Where initiated transactions are verified, settled, and safely finalized.

This split matters because the perspective differs by who is involved. From the agent’s pov, once it makes a decision, it only needs to connect to an interface (a plugin). The agent does not need to understand the infra layer details (signature verification, on-chain settlement, block confirmation) for the transaction to complete. As infrastructure becomes sufficiently abstracted, payment turns into a component that "just works when called."

At the same time, the infra layer continues to evolve to make transactions more efficient. For example, SIWx (Sign-In with X) and session tokens discussed in the x402 ecosystem aim to reduce authentication overhead for recurring payments. There is also ongoing work to increase transaction trustworthiness by protecting an agent’s private keys and payment logic at the hardware level using TEEs (Trusted Execution Environments). As a result, all layers interlock like a single system under the shared objective of enabling the agent economy. In the process, the Trust layer, which was relatively underdeveloped in early x402, is being reinforced, and the overall ecosystem is expanding as existing layers evolve.

3.1 Agent Layer

The agent layer is the starting point of all agent economy activity and the top decision-making layer. Traditional bots performed repetitive tasks mechanically based on pre-defined rules. Agents operate differently at the core: once given a goal, they assess the situation, set constraints, explore execution paths, and complete the task. The essence is autonomous decision-making, not simple automation.

In fact, the concept of AI agents became one of the key narratives in late 2024, rising sharply around the Solana and Base ecosystems. The idea of agents operating independently on blockchain was already familiar to many people. However, at the time, there were clear practical limitations. It was difficult to fully delegate complex tasks to agents or expect sophisticated judgment across multiple steps.

Existing frameworks required developers to specify tool invocation order and branching logic in advance, and services without APIs were often inaccessible. Without a carefully designed workflow built by humans, there was a clear ceiling on an agent’s ability to autonomously create value. OpenClaw’s emergence fundamentally changed this. Agents could move beyond an experimental narrative and gain a foundation to become real on-chain economic entities.

OpenClaw is built on computer-use capabilities, allowing agents to directly manipulate real computing environments such as browsers, terminals, and file systems. This enables access even to services without APIs, and allows LLMs to interpret on-screen context and decide the next action. When this approach is combined with x402-native payments via agent skills, it becomes possible to complete the full economic action loop inside one framework: decision, execution, payment.

Source: X(@base, @solana, @monad)

Base and Solana, which lead x402 adoption, and even emerging protocols like Monad (@monad), are reframing x402 as core infrastructure for the agent economy and building new narratives around it. As more agents with autonomous execution capabilities like OpenClaw emerge, coupling with x402 can create a flywheel effect that accelerates growth. Below are key projects in this agent layer.

3.1.1 OpenClaw, the Operating System of the Agent Economy

Source: Openclaw.ai

Launched as an open-source autonomous AI agent in November 2025, OpenClaw has established itself as the operating system of the agent economy. Numerous agent-based projects now run on OpenClaw or integrate with it. It has effectively become the flagship framework representing the current generation of AI agent systems.

In particular, OpenClaw supports x402 payments natively at the framework level through Agent Skills, enabling agents to complete payments with no additional configuration. As OpenClaw’s influence grows, it is increasingly common to see x402 projects develop and distribute their own OpenClaw x402 skills.

3.1.2 Virtuals Protocol, an Agent Launchpad

Source : Virtuals Protocol

Virtuals Protocol (@virtuals_io) is an AI agent launchpad and tokenization platform where anyone can create agents, tokenize them, and trade them in a marketplace. It operates an agent ecosystem through ACP (Agent Commerce Protocol) and Butler AI, and builds an A2A (agent-to-agent) economy in which agents can hire other agents and pay them. In cases where specialized external agent services are required for a task, the Virtuals marketplace serves as an "agent outsourcing" layer.

3.1.3 BANKR, a Trading Agent for Agents

Source: BANKR

BANKR (@bankrbot) is a representative example of a trading agent that generates real revenue in the agent economy. It interacts with other agents using ERC-8004-based trust authentication and x402 payments, positioning itself as an economically self-sustaining agent with its own revenue model.

If other agents "buy" external services via x402, BANKR does the reverse: it offers on-chain financial actions (token buys, balance checks, token distribution, perpetuals, and more) as agent-based services and charges x402 payments in return. This makes it symbolic as an agent that not only uses payments, but earns money through payments.

3.1.4 Daydreams, an x402 Payment-Optimized Agent Framework

Source: Daydreams

Daydreams (@daydreamsagents) is a stateful agent framework optimized specifically for x402 payments. If OpenClaw is a general-purpose agent OS, Daydreams is a project that optimizes the act of agents earning and spending money at the framework level.

Each agent operates as a "nanoservice" and comes with a built-in x402 micro-payment model that charges per interaction (for example, $0.10 per chat). Computation, payment, and metadata processing run together in a single call, and payment policy enforcement and spending-limit management are handled at the framework level. It supports omnichain environments (Base, Solana, Ethereum, Starknet) and implements its own x402 facilitator so that multi-chain micro-payments can be completed inside the framework.

3.1.5 Heurist, Full-Stack AI Intelligence Infrastructure

Source : Heurist

Heurist (@heurist_ai) provides full-stack infrastructure for the AI economy. If OpenClaw covers the general-purpose agent OS role, Heurist focuses on providing an integrated stack for how agents become "smarter."

The centerpiece is Heurist Mesh, a marketplace. Heurist Mesh converts high-quality Web2 and Web3 data sources and APIs into composable agent units and makes them compatible with the x402 payment protocol. This enables agents to combine token analytics, social intelligence, and on-chain data into a single workflow and autonomously execute complex research. Beyond that, Heurist also operates its own x402 facilitator and the Heurist Chain (a ZK L2-based micro-payment infrastructure), building an internal ecosystem that completes the loop from knowledge acquisition to execution and payment.

3.2 Interface Layer

The interface layer is the connection point where AI agents interact with external services and other agents. By abstracting the payment, authentication, and settlement logic of lower layers, it enables agents to discover APIs and perform payment and execution through a single plugin. This layer develops in two directions.

• Bottom-up: Individual projects in the x402 ecosystem build and distribute native interfaces in the form of agent skills.

• Top-down: Platforms like Coinbase, Cloudflare, Vercel, and Stripe integrate x402 directly into developer tools.

3.2.1 Bottom-up: Agent-Native Interfaces

These plugins connect to lower-layer infrastructure and abstract away complexity. APIs are packaged as skills that agents can access, so that once a developer installs a single skill, payment is handled automatically. Below are notable examples.

• x402scan-skills: A plugin created by Merit Systems (@merit_systems), the team behind x402scan.com. It bundles paid x402 APIs across eight categories, including media generation, web research, and social intelligence, into a single Claude skill package.

• Clawdexter: The official plugin from Dexter AI (@dexteraisol). It unifies the process where an agent discovers tools via MCP, pays through x402, and receives results in a single flow. It supports multiple chains including Solana, Base, Polygon, and Avalanche, and also provides an ERC-8004-based agent identity and reputation system.

• Openclaw-acp: A plugin announced by Virtuals Protocol (@virtuals_io) on February 1, 2026. It allows OpenClaw agents to outsource tasks to specialized agents in the Virtuals marketplace and automatically settle via on-chain escrow and x402 micro-payments.

• Allium x402-skill: Allium (@AlliumLabs), an enterprise-grade blockchain data infrastructure provider, has opened its infrastructure to AI agents via AgentHub. Agents can instantly access real-time token prices, wallet balances, transaction history, and on-chain event alerts across more than 150 chains through x402 payments. It integrates with Privy (@privy_io) agent wallets, and mainnet deployment is expected soon.

3.2.2 Top-down: Big Tech x402 Integrations

• Coinbase Developer Platform (CDP, @CoinbaseDev): The primary designer and default facilitator of x402. It connects on-chain payments to AI frameworks via the AgentKit SDK and Payments MCP in a plugin-like form. Through the x402 Bazaar discovery layer, it also enables agents to automatically discover paid services. On February 12, 2026, it announced an agentic wallet, followed by x402 payment support for the SQL API on February 13, continuing to drive x402 ecosystem expansion.

Source : Coinbase Developer Platform

• Cloudflare (@Cloudflare): On September 23, 2025, Cloudflare co-founded the x402 Foundation with Coinbase and embedded x402 v2 payments natively into its agent SDK. When an agent is deployed on Workers, payment and MCP authentication are automatically applied. Cloudflare also open-sourced the x402-proxy-template, allowing website owners to set route-based micro-payments per download or per API call crawl unit.

Source : X(@williamallen)

• Stripe (@stripe): On February 11, 2026, Stripe officially launched Base x402 USDC payments via the PaymentIntents API. When an agent pays on-chain, Stripe automatically converts it to USD and settles through the existing dashboard. Future integrations such as Privy wallet support or applying the Tempo network are also possible.

Source : X(@base)

• Vercel (@vercel): On September 13, 2025, Vercel announced the x402-mcp package, integrating the AI SDK with x402 payments. If paid tools are defined on an MCP server, payments execute automatically when an agent calls the tool. Vercel also made it easy to integrate x402 payment modules quickly through a one-click template.

Source : X(@vercel)

3.3 Protocol Layer

The protocol layer defines the rules and procedures for agent-to-agent payments and is the core of the x402 stack. Here, the focus is on the x402 v2 stack and ERC-8004.

Strictly speaking, ERC-8004 is less an x402-only standard and closer to an on-chain identity and reputation standard for the broader agent economy. However, because x402’s ultimate goal is to implement an open agent economy, the agent identity and reputation layer is effectively bound tightly to the x402 stack. In addition, many derived identity and reputation mechanisms are emerging on ERC-8004, which is EVM-based (Ethereum Virtual Machine). For those reasons, this section covers ERC-8004 as part of the protocol layer.

3.3.1 x402 v2: A Three-Layer Structure of Signaling, Settlement, and Identity

x402 v2, released in December 2025, separates the protocol into three layers: Signaling, Settlement, and Identity, so each concern can evolve independently.

• Signaling Layer: This layer detects when payment is required and exchanges conditions. When an agent tries to access a paid resource, the server returns a 402 trigger instead of data, indicating payment is required. The key change in v2 is where payment metadata lives. In v1, payment info was included in the response body, but in v2, all payment metadata moved into HTTP headers. The server includes payment conditions in the PAYMENT-REQUIRED header, and the agent responds with wallet signatures in the PAYMENT-SIGNATURE header.

• Settlement Layer: v2 formalizes an extension system that allows independent modules to be added without forking the protocol. For example, the Discovery Extension enables facilitators to automatically crawl and index structured metadata from service providers, allowing agents to discover what services exist, where they are, and how much they cost. The A2A x402 extension for Google AP2 integration and lifecycle hooks that insert custom logic before or after payment also operate within this system. Payment methods are also part of the extension model. Payment schemes such as Exact (fixed fee), Upto (usage-based up to a cap), and Deferred (postpaid) can be registered as plugins according to service needs. In particular, Deferred is a scheme proposed separately by Cloudflare, designed for a model where trusted crawlers collect large volumes of data first and settle in batches later.

• Identity Layer: This layer proves an agent’s identity and reduces repeated authentication friction. Using CAIP-122-based SIWx (Sign-In with X), an agent proves identity with a one-time wallet signature, and then re-accesses resources using only a server-issued session token. This reduces delays from repeating on-chain signing and verification on every request, enabling Web2-style user experiences such as subscriptions or session-based billing on top of on-chain infrastructure. This functionality is planned for an upcoming v2 follow-up release.

In short, the signaling layer detects payment requirements and receives conditions, the settlement layer selects and executes billing schemes, and the identity layer reduces repeated authentication friction.

3.3.2 ERC-8004: Agent On-chain Identity and Reputation Standard

Source : 8004.org

Assume an agent must choose one service among many agents to achieve its goal. Humans decide based on reputation and trust. What should agents decide on?

ERC-8004, launched on mainnet in January 2026, is an answer to that problem. It is an Ethereum standard that extends Google’s A2A protocol and uses blockchain to implement an open agent economy where agents can be discovered, selected, and interacted with across organizational boundaries without prior trust. ERC-8004 defines three on-chain registries to identify agent identity and trust.

• Identity Registry: Assigns each agent an ERC-721-based on-chain identity. This identity links to an Agent Registration File that contains the agent’s role, endpoints, supported protocols, and more, allowing other agents or services to discover and identify counterparts.

• Reputation Registry: A standardized interface for posting and querying feedback signals after transactions complete. ERC-8004 does not compute scores itself. It standardizes only the collection and retrieval of feedback data. Scoring and aggregation are delegated to specialized on-chain and off-chain services, allowing different reputation algorithms to compete on the same underlying data.

• Validation Registry: A framework where independent validators verify an agent’s work results and record verification outcomes on-chain. It can accommodate diverse validation models, including staking-based validation, zkML, and TEE oracles. For example, if Agent A wants to call an image generation API, it can confirm the API provider agent’s identity via the identity registry and check the feedback history in the reputation registry to evaluate service quality and fulfillment reliability. Conversely, the service provider can verify the requesting agent’s payment fulfillment history to filter malicious requests.

3.4 Trust Layer

The trust layer can be divided into Computational Trust and Heuristic Trust. Computational trust focuses on protecting and proving payment logic and computation results. Heuristic trust provides methods to assess the trustworthiness of the agents that buy or provide services.

3.4.1 Computational Trust

Computational trust answers two key questions.

First: after paying, did the agent receive the correct service?

The case where Builder.ai, which marketed itself as AI and reached a 1.5 billion dollar valuation, was revealed to have relied on hundreds of human workers manually writing code and subsequently went bankrupt shows that verifiability of off-chain computation is not merely a technical challenge. It is a prerequisite for economic trust. In agent-to-agent transactions, where computation such as AI inference runs off-chain, ensuring integrity of results becomes the central challenge. EigenCloud and OpenGradient address this using TEE-based isolated execution and cryptographic proofs.

Second: was the payment itself executed securely?

If an agent’s keys are stolen or signatures forged, payment trust collapses. Heima combines TEE and account abstraction to secure payment execution, while Xyber cryptographically proves all agent actions, enabling a model where payment happens only after verifiable task completion.

• EigenCloud (@eigencloud): A verification infrastructure that leverages EigenLayer restaking security. Agents perform payment signing inside TEE-based isolated environments to prevent key theft. EigenCloud cryptographically proves the integrity of LLM inference results and can preserve input and output data in a verifiable form for dispute resolution. It participates as a co-developer of Google AP2 by providing verifiability infrastructure, and plays a central role in building trust-based agent economies when combined with ERC-8004.

Source: blog.eigencloud.xyz

For a deeper explanation, see "EigenCloud: In Search of What is Truly One's Own.

• OpenGradient (@OpenGradient): Rather than providing general infrastructure, it focuses on verifiable LLM inference based on x402. All inference runs inside a TEE, and it provides cryptographic proofs that the results were produced correctly.

Source: Opengradient

• Heima (@heimaNetwork): Secures x402 payment execution by combining TEE with account abstraction (ERC-4337). It protects agents from key theft by generating keys and signing inside a TEE, while enabling a flexible payment environment beyond EOA limitations via smart-account programmable wallets. This includes gasless transactions, multi-chain payments, and standard ERC-20 token support.

Source: X(@hemiaNetwork)

Ultimately, computational trust provides verifiable answers to both axes: whether payment was executed securely, and whether paying produced the correct result.

3.4.2 Heuristic Trust

If computational trust focuses on proving the integrity of computation, heuristic trust provides criteria to judge the trustworthiness of agents themselves. In an agent economy where agents must choose optimal counterparts among countless services, new trust mechanisms that replace human reputation systems are essential.

Solutions split into two approaches. The first is dynamic verification: using AI validator networks to audit an agent’s identity, code, and behavior in real time and produce a credit rating. Clawcredit from t54.ai is an example. The second is static verification: standardizing on-chain identity and reputation histories through standards like ERC-8004 to support discovery and identification. SIWA and 8004Scan fall into this category.

• t54.ai (@t54ai): t54.ai is a trust infrastructure that assigns credit to agents. Its flagship product, Clawcredit, evaluates an agent in real time through t54’s risk engine (Trustline), assessing identity, behavioral patterns, and code audits to issue an autonomous credit line. With this credit, an agent can immediately pay for x402 services without holding funds upfront. As usage history and repayment patterns accumulate, the credit score rises, enabling higher limits and cashback, mirroring the credit growth model in human finance. It is currently one of Solana’s representative agent reputation protocols and is also available as an OpenClaw skill.

Source : X(@t54ai)

• SIWA (Sign In With Agent, @builders_garden): SIWA is an agent authentication protocol based on ERC-8004 and ERC-8128. With a single prompt, an agent can generate a wallet, register on-chain, and authenticate to services. Authentication completes using only the agent’s on-chain identity, without API keys or shared secrets. From the service provider’s perspective, it becomes possible to verify who is calling the API on every request. Notably, it was co-created by Builders Garden and the Ethereum Foundation dAI team, and is also available as an OpenClaw skill. If ERC-8004 gives agents identities, SIWA is the authentication protocol that lets agents "log in" to services using those identities.

Source : X(@ethereum)

• 8004Scan (@8004_scan): 8004Scan is a dedicated block explorer that searches and verifies the identity, reputation, and performance of agents registered via ERC-8004. Just as Etherscan explores transactions and contracts, 8004Scan explores agents. It also functions as a discovery platform that helps find agents on Base and connect them to x402 services. In other words, if ERC-8004 is the standard that registers agent identities on-chain, Clawcredit computes credit ratings using that identity data, and 8004Scan is the explorer that makes this information searchable for anyone.

Source : 8004scan

3.5 Facilitator Layer

The facilitator layer is the execution layer that converts protocol-layer payment rules into real blockchain transactions. It verifies the payment information submitted by agents and processes payments on-chain on behalf of the server.

In principle, facilitators are not mandatory in x402. x402 transactions can function without a facilitator. However, using facilitators allows service providers to receive blockchain payments with minimal blockchain-specific development, making them a "fast integration" path that accelerates x402 adoption. The flow is simple. When an agent sends a signed payment payload to the server, the server forwards it to the facilitator’s /verify endpoint. The facilitator performs scheme-specific verification and on-chain settlement. Because verification is scheme-based, it becomes difficult for facilitators or resource servers to move funds in ways that deviate from the agent’s intent. Key facilitators include:

• Coinbase: A co-designer of x402 and a co-founder of the x402 Foundation. Coinbase offers its CDP payment infrastructure as a facilitator, with up to 1,000 requests per month free and a fee of $0.001 per request afterward. It serves as the default infrastructure handling a large share of x402 volume, with deep native integration on Base as a key advantage.

• PayAI (@PayAINetwork): A Solana-first multi-network facilitator. It processes payments from $0.01 in under one second and provides Echo Merchant (a free testing environment) so developers can test x402 transactions without costs. It also runs an agent hiring marketplace called Freelance AI, and is working with AWS and Google Cloud to expand x402 support at the cloud infrastructure level.

• Dexter AI: A facilitator strong in multi-chain payment routing, handling payments across Solana, Base, Polygon, and also Arbitrum, Optimism, Avalanche, and more through a single interface. It can be integrated with minimal code via the @dexterai/x402 npm SDK, and on the day Stripe launched x402 it shipped v1.7.0 to support Stripe PaymentIntent settlement.

• Daydreams: As a payment-specialized agent framework, Daydreams implements its own facilitator. It enforces agent payment policies and manages spending limits inside the framework, completing omnichain micro-payments at the framework level.

Heurist and Virtuals Protocol also operate their own facilitators. To use multiple facilitators more efficiently, x402 v2 shifted facilitator architecture to a plugin-based model. Anyone can add a new chain or payment model as an independent package, encouraging competition and specialization among facilitators and giving agents better options.

3.6 Blockchain Layer

The blockchain layer is the lowest layer in the x402 stack, where final settlement and state recording happen for all payments. All economic activity in higher layers ultimately resolves into on-chain transactions here. Three representative protocols handling x402 include Base, Solana, and Polygon.

• Base: An Ethereum L2 built by Coinbase, and effectively x402’s home chain. With Coinbase participating in x402 design and co-founding the x402 Foundation with Cloudflare, native integration at the protocol level is deepest. Low gas fees and fast finality make it well-suited for micro-payments, and it is also the default network for the current x402 reference implementation.

• Solana: With high throughput and extremely low transaction costs, Solana is strong for large-scale agent-to-agent micro-payments. The Solana Foundation actively supports x402 as core infrastructure for the agent economy and even operates a dedicated Twitter account, x402 on Solana (@x4o2), to nurture the ecosystem. Thanks to the modularized SDK in v2, a Solana-native paywall package is provided, and Solana’s presence in real transaction volume has grown.

• Polygon: Polygon’s differentiation comes from offering scalability in an EVM-compatible envirnt and enabling easy integration with existing Ethereum ecosystem DeFi infrastructure. With facilitator support on Polygon and growing agent usage, it is capturing transaction share by real volume.

Notably, x402 v2 adopted CAIP (Chain Agnostic Improvement Proposals) standards to introduce a chain-agnostic network identification system. This implies that beyond the current three chains, new L1 and L2 networks can be added as independent packages. It is a direction toward reducing chain dependency and expanding x402 into a general-purpose payment infrastructure.

Ultimately, the blockchain layer is the trust anchor of the entire x402 stack. No matter how sophisticated protocols and verification become at higher layers, a transaction is only complete once it is recorded on an immutable ledger. By supporting multiple chains, agents can choose the optimal settlement layer based on cost, speed, and ecosystem compatibility.

4. Where x402 Stands Today and What Comes Next

4.1 Why Real Tx and Gamed Tx Metrics Matter

Artemis (@Artemis) classifies x402 transactions into Real Tx and Gamed Tx. This methodology was devised by Artemis’s Lucas (@OnchainLu) to effectively identify wash trading. To capture diverse wash trading techniques, he has continuously refined a proprietary combination of heuristics.

Source : X(@OnchainLu)

The detailed logic is not publicly disclosed. This is a precaution to prevent projects from gaming the metric, a paradoxically it highlights how important this indicator is within the ecosystem.

Once a protocol secures a leading position, receiving corresponding rewards is natural. However, some malicious projects repeatedly generate fake transactions purely to satisfy specific KPIs without providing meaningful contributions. Just as wash trading indicators became a key tool for assessing market health in the NFT sector, the x402 ecosystem also needs a comparable metric, and the Gamed Tx indicator serves that role.

Building a healthy x402 ecosystem requires these metrics as a foundation. The core is not just aggregating numbers, but creating indicators that use multiple metrics to extract meaningful signals from noisy data.

4.2 The x402 Protocol Is Maturing, but It Still Needs a Killer App

Looking at x402 transaction data through the Real Tx metric, the protocol appears to be moving beyond experimentation and entering a real growth trajectory. In August 2025, daily Real Tx averaged only around 400. Starting in late October, it began to rise sharply, reaching roughly 1.75 million in a single day on December 14. Total Real Tx in December reached approximately 44.42 million. The share of Gamed Tx once approached 90% but has now converged below 10%, indicating ecosystem maturation.

However, the absolute scale of Real Tx makes it difficult to be purely optimistic. Daily average Real Tx, about 1.43 million in December, fell to about 740,000 in January 2026, and to about 180,000 in February (as of the 11th), showing a clear downward trend.

Transaction composition supports this view. Most x402 activity is currently concentrated in A2A (Agent-to-Agent) and DaaS (Data-as-a-Service) queries. As February began, the number of A2A transactions, which had maintained a significant share, dropped sharply, and the Infrastructure and Utilities segment showed a similar decline.

Taken together, the conclusion is that x402 still lacks a sufficient killer app that can drive sustained demand. The projects reviewed in Section 3 are infrastructure and tools that fill each layer of the x402 stack. They are plumbing that enables agents to pay, not killer applications that create the underlying reason why payment is needed. The plumbing exists, but there are not enough applications to create consistent flow through it.

For a protocol to truly settle in, it needs applications that lead value capture on top of it. In the 2021 cycle, Uniswap and OpenSea played that role, and the protocols they ran on benefited significantly. The same logic applies here. For x402 to become a central axis of the agent economy, it will need comparable applications.

What form the killer app will take is still unknown. However, many L1 and L2 foundations are positioning the agent economy and x402 as key narratives and hosting hackathons, and Big Tech companies are actively pursuing x402 integration. The soil is ready. The emergence of killer apps is a necessary condition for x402 to move beyond an experimental protocol into broad adoption.

4.3 Cross-Chain Competition, a Requirement for a Healthy Ecosystem

x402’s Real Tx share by chain is also showing meaningful change. When Realx began to be observed in earnest during August and September, Base, the chain where x402 was first implemented, effectively accounted for 100% of transactions, a de facto single-chain ecosystem. In October, Solana joined and the multichain transition began. In December, Solana overtook Base with 61% versus 39%. In January 2026, Polygon expanded to 11%, forming a three-way structure. In February, Solana holds a dominant share at 82%.

If Base is the center of protocol design and reference implementation, Solana is the center of real transaction volume. This divergence suggests that x402 is evolving into a general-purpose protocol rather than being owned by a single chain. It can be interpreted as a result of Solana’s low transaction costs and fast confirmation speed providing an advantage in real-world micro-payment usage. It also shows that Base’s "home chain" status is more about governance and standards, not a guarantee of market share.

For a deeper discussion on Polygon’s share, see "x402 on Polygon : Is it GAMED?".

There are other chains as well, but for now these three form the core of the x402 ecosystem. Competition across chains is inherently positive for x402 expansion. Each chain has distinct technical characteristics across fee structure, throughput, and developer tooling. As each optimizes for x402, the technical maturity of the whole ecosystem rises naturally. This competition also reduces dependency risk on any single chain and provides wider options for users and developers, lowering adoption barriers.

We are also seeing examples where this competition directly drives innovation. For instance, ERC-8004 is designed on an EVM-based stack, making it hard to apply directly to Solana’s SVM (Solana Virtual Machine) environment. To address cross-chain compatibility issues like this, cross-chain trust layers such as t54.ai are emerging. In other words, a multi-chain environment can become a catalyst for new infrastructe innovation.

4.4 In the End, It Is the Trust Layer

x402 is not just a payment protocol. It is an attempt to design the nervous system of the agent economy. The idea of putting payments on HTTP is simple, but for it to work effectively in practice, it must be supported by a layered trust stack: discovery, security, and integrity. x402 has moved beyond proving technical possibility and is entering a phase where this trust stack must be validated under real conditions. The projects reviewed earlier are filling the pieces of computational trust and heuristic trust, but in the end these pieces must converge into a single trust stack. No matter how sophisticated each component is, if they are not integrated, agents will still be forced to transact with uncertain counterparties and unverifiable services.

This is the core of the agent economy. By removing human judgment, it gains speed and scalability, but precisely because human judgment is removed, it must rebuild trust in code. The future of x402 depends on how completely it resolves this burden. The turning point where the protocol becomes infrastructure for everyone will not come from adding features, but from completing trust.

The push to elevate blockchain protocols into infrastructure is not limited to x402. Efforts to bring L1 and L2 networks into the settlement layer of traditional finance are another example. But all these attempts share the same challenge: for a protocol to become infrastructure, repeated economic activity must occur on top of it, and that repetition requires trust.

Just as traditional finance built trust infrastructure over decades through regulation, audits, and credit ratings, the agent economy will need its own trust stack. The difference is that this time, it must be built not through human institutions, but through code and cryptography. x402 stands at the front line of this experiment.

"In a world where Agents pay Agents, how should trust work?"

How x402 answers that question will set a precedent not only for the agent economy, but also for the broader shift where blockchain protocols evolve into infrastructure.