AI agents are getting really good at completing complex workflows across the internet, but the infrastructure that lets them buy services autonomously is only beginning to take shape. Agentic commerce is the emerging infrastructure that lets agents discover tools, pay for digital services, and execute transactions autonomously. Protocols such as MCP, ACP, x402, UCP, L402, and (most recently) MPP are early attempts to build this infrastructure. They’re the foundation of what may become an agentic economy.
Key terms in agentic commerce
The ecosystem around agentic commerce is developing quickly, and several new concepts and protocols are popping up at the same time. The glossary below defines key terms we’ll refer to in this article.
| Term | Definition |
|---|---|
| Agentic Commerce Protocol (ACP) | An open standard for programmatic commerce flows between buyers, AI agents, businesses, and payment providers, co-developed by Stripe and OpenAI. ->See the closer look at core protocols below. |
| Agentic commerce | Infrastructure that lets AI agents discover, evaluate, and buy services autonomously instead of humans using websites or APIs manually. |
| Agentic commerce stack | The layered infrastructure behind agent transactions, typically including tool connectivity (MCP), identity and trust (KYA, ERC-8004), authorization, payments (ACP, x402, UCP, L402), and observability. |
| Agentic economy | A digital economy where autonomous AI agents participate in economic activity such as finding services, buying resources, and coordinating work. |
| Agentic payments | Payment systems designed for AI agents, allowing software to pay programmatically for APIs, datasets, compute, or automation tools. |
| Agent-to-Agent (A2A) | Transactions that occur directly between autonomous AI agents, such as one agent paying another for specialized tasks. |
| AI agent | Software capable of pursuing goals autonomously by reasoning, using tools, and executing actions, often combining LLMs with APIs and external tools. |
| Business-to-Agent (B2A) | Commerce where businesses sell services directly to AI agents, such as API access, datasets, automation services, or compute. |
| ERC-8004 | An Ethereum standard for agent identity and trust with Identity, Reputation, and Validation registries for cross-organization agent discovery. |
| Know Your Agent (KYA) | Identity and trust infrastructure for autonomous agents, similar to KYC for humans, used to verify agents and establish trust. |
| L402 (Lightning HTTP 402) | A protocol combining HTTP 402 with Bitcoin Lightning Network payments to gate API access. Predates x402 and shares the same HTTP status code concept, but settles over Lightning rather than stablecoins. ->See the closer look at core protocols below. |
| Machine Payments Protocol (MPP) | An open-source standard for machine-native payments co-authored by Stripe and Tempo, launched March 2026. It defines how agents and services coordinate payments programmatically. ->See the closer look at core protocols below. |
| Model Context Protocol (MCP) | Open standard from Anthropic for connecting AI agents to external tools and services via a standardized interface. ->See the closer look at core protocols below. |
| Universal Commerce Protocol (UCP) | An open standard for commerce developed by Shopify that enables AI agents to interact with merchant storefronts in a standardized way. ->See the closer look at core protocols below. |
| Visa Trusted Agent Protocol | A framework developed by Visa that lets AI agents authenticate and transact on behalf of consumers using verified, tokenized credentials. Announced in partnership with Skyfire's KYAPay protocol. ->See the closer look at core protocols below. |
| x402 | Machine-native payment protocol built on HTTP 402, created by Coinbase. Settles via stablecoins on Base and Solana. ->See the closer look at core protocols below. |
Why agents need the ability to pay
AI agents can research markets, write code, analyze datasets, coordinate workflows, and interact with external services through APIs and tools. As large language models become more capable and agent frameworks mature, these systems are moving beyond isolated tasks toward multi-step autonomous workflows.
But the capability of AI agents to easily buy things at scale is still not widely adopted.
An agent may know exactly which dataset it needs, which API will produce the best answer, or which service provider could complete a task. Yet the moment money needs to move – purchasing access to data, paying for compute, or hiring another service – the workflow usually stops and waits for a human.
Without purchasing capabilities, AI agents remain powerful assistants rather than autonomous economic actors.
This is giving rise to a new category of infrastructure: agentic commerce.
Over the past year, several protocols have emerged in this space.
This article introduces a taxonomy of these protocols and explains the infrastructure behind the agentic economy.
Revisiting HTTP 402
Interestingly, the idea of machine-native payments on the internet isn’t new.
The original HTTP specification defined a status code called 402 Payment Required.
The concept was straightforward: a server could request payment before granting access to a resource.
In practice, however, the mechanism was never implemented. When the web was created in the early 1990s, the infrastructure needed to process digital payments simply didn’t exist.
Instead, payments evolved through systems layered on top of the web:
- Credit card networks
- Online checkout flows
- Payment processors such as PayPal and Stripe
These systems work well for human users but were never designed for a world in which software agents may execute thousands of transactions autonomously.
Today, the rise of AI agents is reviving interest in the original idea of native payments embedded into the internet’s protocol layer.
Protocols such as x402 attempt to bring the HTTP 402 concept to life by allowing servers to request payment before delivering digital resources such as APIs, data, or compute.
In other words, the web may finally be gaining the payment primitive it was designed to support.
What a fully autonomous agentic workflow requires
Consider a research agent tasked with producing a market analysis report. To complete the job, the agent might need to:
- Discover specialized data providers
- Access premium datasets
- Call external APIs
- Run web scraping tools
- Pay for compute resources
Without the ability to purchase these services independently, the agent must repeatedly defer to a human operator.
In an agentic economy, AI agents become participants in economic activity – discovering services, paying for capabilities, and potentially selling services of their own.
These interactions can take several forms, which we’ll cover below.
A taxonomy for agentic commerce
Traditional internet commerce is usually described with human business labels: B2B, B2C, C2C. Those still matter, but they’re no longer enough. In the agentic economy, a useful working taxonomy looks like this:
1. Human-in-the-loop consumer commerce
An agent helps a user discover and buy something, but the purchase is still fundamentally a consumer checkout flow. The buyer is human, the merchant is human-facing, and the agent is an interface plus orchestrator.
This is the world of ACP (Agentic Commerce Protocol).
Stripe and OpenAI describe ACP as an open standard for programmatic commerce flows between buyers, AI agents, businesses, and payment providers. Sellers remain the merchant of record. Agents render the checkout UI, collect selections and payment credentials, and pass structured information through the flow. In other words, ACP doesn’t reinvent the internet’s payment rails. It makes existing e-commerce checkout legible to agents.
2. Agent-to-Business (A2B) operational payments
A2B is where an agent is authorized to pay a business for a service, workflow step, contractor, or resource. Think procurement, scheduling, data access, SaaS usage, contractor payouts, or a workflow agent paying for a specialized downstream service.
A large portion of early agentic payments may not look like shopping at all. They may look like AP/AR, payroll displacement, contractor remittance, or operational purchasing.
That’s an important market correction. The dominant demos in agentic commerce today are about buying shoes, skincare, and headphones. The larger opportunity may be agents moving business money.
3. Agent-to-Agent (A2A) service exchange
A2A is the most ambitious category and the one that gives the agentic economy its name. One agent hires another, delegates a subtask, purchases data or inference, pays for verification, or coordinates a multi-step workflow across organizational boundaries.
This is where the agentic economy goes beyond theory, and we can start talking about “agent GDP,” meaning the revenue agents generate both from serving humans and from participating in the Agent-to-Agent economy.
This category is the least mature, but it’s also the most transformative. Pure A2A payments are still early because the agent landscape remains too unspecialized, and interoperability is still developing. But once specialized agents owned by different companies begin transacting at scale, A2A becomes a P0 infrastructure problem.
The agentic economy stack
Once you stop treating all agentic commerce as one thing, the architecture becomes much clearer.
The discovery layer
This is how agents find and connect to capabilities. MCP is the breakout standard here. Anthropic introduced it in November 2024. It solves how an agent connects to and uses a tool, not how it pays for one.
The identity and trust layer
Skyfire's KYA protocol handles verified agent identity; its KYAPay protocol combines identity with payment authorization. ERC-8004 provides the equivalent on-chain via Ethereum registries. Neither handles payments directly – both establish who the agent is before a transaction occurs.
On the blockchain side, ERC-8004 is an Ethereum standard that introduces on-chain Identity, Reputation, and Validation registries for agents. It’s a trust and discovery layer only – payments are explicitly outside its scope, though it’s designed to interoperate with payment protocols such as x402.
This layer will matter more than many people realize. In human commerce, identity is implicit in the stack: phone numbers, government ID verification, card ownership, and account history collectively establish that a buyer is probably a real person. Agents need their own equivalent. Without that, the market fills with anonymous buyers, unpriced risk, and weak fraud controls.
The authorization layer
Not every agent that can decide should be allowed to spend. Someone has to define limits, delegated authority, approved vendors, risk thresholds, and exception handling. So, agents need ways to transact over the best available rail while preserving auditability, reconciliation, and controls.
ACP handles this within a checkout framework through delegated payment credentials and seller-controlled flows. Skyfire handles part of it through tokenized identity and payment credentials.
The payments layer
Next is the machine-native payment infrastructure, where the payment itself is programmatic and designed for autonomous clients and services.
ACP handles human-linked checkout; x402 handles machine-native pay-per-use over HTTP. UCP handles the commerce interaction layer within Shopify's ecosystem. L402 provides the Bitcoin Lightning equivalent of x402 for Bitcoin-native services.
Stripe's Machine Payments Protocol extends this further: a rail-agnostic open standard that adds a sessions primitive for continuous agent micropayments across stablecoins, cards, and Lightning.
The observability layer
Once agents are making financial decisions, you need observability and tracing that can capture both deterministic system events and non-deterministic agent decisions.
In enterprise settings especially, agentic payments won’t scale without a financial paper trail that humans can inspect.
A closer look at the core protocols
Model Context Protocol (MCP)
MCP was developed by Anthropic and open-sourced in November 2024. It provides a standardized interface for AI agents to connect to external tools, data sources, and services. It eliminates custom integrations: developers implement MCP once and gain access to any compatible server. MCP has seen rapid adoption, with implementations from OpenAI, Microsoft, and thousands of community-built servers.
MCP doesn’t handle payments. It’s the connectivity layer that makes tools accessible – a prerequisite for the rest of the stack.
Agentic Commerce Protocol (ACP)
ACP is an open standard for agent-mediated consumer checkout, co-developed by Stripe and OpenAI and launched in September 2025.
It defines how AI agents can initiate and complete purchases on behalf of human buyers within existing merchant infrastructure, without the merchant losing control of the customer relationship.
The key design principles: merchants remain the merchant of record; agents render checkout UI and collect selections; payment credentials are passed as scoped tokens (Stripe's Shared Payment Token) rather than raw card details; sellers can accept or decline transactions per agent, per transaction, or via custom logic.
ACP isn’t designed for machine-to-machine payments. The end buyer is always a human.
x402
X402 was created by Coinbase and is co-governed by the x402 Foundation (established with Cloudflare in September 2025). It revives the long-dormant HTTP 402 status code to enable machine-native payments directly over HTTP.
Current implementation settles in USDC on Base and Solana. No accounts, sessions, API keys, or checkout flows required.
Current limitations: x402 currently supports two payment schemes: exact (client pays a fixed amount) and up to (client authorizes up to a maximum). More flexible pricing models, fiat settlement, and multi-rail support are on the roadmap but not yet available. The Coinbase Developer Platform operates the primary facilitator, though the protocol is permissionless and anyone can run one.
Machine Payments Protocol (MPP)
MPP is an open-source standard for machine-native payments co-authored by Stripe and Tempo and launched on March 18, 2026. Where ACP handles human-buyer checkout, and x402 handles HTTP-native stablecoin pay-per-use, MPP is designed as a general-purpose agent payment layer that works across multiple rails and payment types.
MPP introduces a "sessions" primitive: an agent authorizes a spending limit upfront and can then stream micropayments continuously without an on-chain transaction per interaction. This makes it well-suited to continuous agent activity – paying per API call, per token of inference, per browser session – rather than discrete one-off purchases.
Currently, MPP runs on Tempo, but the protocol is explicitly rail-agnostic. Visa has extended it to card-based payments, Lightspark has extended it to Bitcoin Lightning, and Stripe has extended it to cards, wallets, and other payment methods through its platform. Stripe users can accept MPP payments via the PaymentIntents API in a few lines of code, with funds settling into existing balances in their default currency on their standard payout schedule.
Universal Commerce Protocol (UCP)
UCP is an open protocol developed by Shopify that lets AI agents interact with merchant storefronts in a standardized way. It covers product discovery, cart management, and checkout. Where ACP defines the payment credential handshake, UCP focuses on the commerce interaction layer: how agents browse inventory, build carts, and initiate purchase flows within Shopify's merchant ecosystem.
UCP and ACP are complementary rather than competing: UCP handles the shopping interaction, ACP handles the payment authorization.
L402
L402 (Lightning HTTP 402) is a protocol that predates x402 and shares the same foundational concept: using HTTP 402 to gate API access with a payment. The key difference is the payment rail – L402 settles over the Bitcoin Lightning Network rather than stablecoins, so it’s native to Bitcoin developer tooling.
L402 is less broadly adopted than x402 but was established earlier and is influential in shaping the machine-native payments concept.
Visa Trusted Agent Protocol and Mastercard's agent commerce initiative
Visa and Mastercard are both building trust and payment infrastructure for the agentic economy within existing card rails.
Visa's Trusted Agent Protocol was demonstrated in partnership with Skyfire. It lets AI agents authenticate and transact on behalf of consumers using verified, tokenized card credentials. The framework works within Visa's existing network, so merchants get the fraud signals and trust infrastructure they already rely on.
Mastercard has also announced agent commerce capabilities, focused on agents transacting by using tokenized credentials but preserving cardholder controls and issuer visibility.
Both approaches represent the card network strategy: extend existing trust infrastructure to cover agent-initiated transactions rather than building new rails.
Why crypto infrastructure fits agentic payments
Crypto is probably the strongest native case for the agentic commerce market. x402 maps directly to the constraints of machine payments: low fees, near-instant settlement, no chargeback window, global reach, and support for micropayments that would be uneconomical on card rails. Its current implementation makes crypto-native settlement well-suited to the transactions that characterize much agentic commerce.
That said, a complete agentic payment system cannot assume a single rail. Businesses have counterparty preferences – some operate on ACH, some require card acceptance, some may prefer stablecoins. Crypto may be the best native rail for machine commerce, but a winning market architecture will likely be the kind that routes across rails based on transaction type, counterparty requirements, and cost – not the kind that bets on one.
MPP – rail-agnostic by design, with Visa extending it to cards and Lightspark to Lightning on day one – is the first concrete evidence of that multi-rail architecture materialising in production.
Bootstrapping the agentic economy
Launching a new payment system has historically been difficult. Merchants hesitate to support new payment methods until customers use them. And customers hesitate to adopt new payment methods until merchants support them.
This “chicken-and-egg” problem has affected many successful payment systems, including credit cards and PayPal.
Agentic commerce protocols face a similar challenge.
One way to overcome this barrier is to build agentic commerce on top of existing services. Instead of creating entirely new marketplaces, platforms can expose existing tools and services to AI agents.
In this model, agents can:
- Discover services
- Evaluate pricing
- Purchase access
- Execute tasks
This allows the agentic economy to develop gradually alongside the existing digital economy.
Conclusion: It’s about the stack, not the protocol
The agentic economy isn't one market, but a stack of markets. The confusion today comes from mixing together five different problems: discovery, trust, authorization, payment, and observability.
MCP solves discovery and connectivity. ACP solves agent-ready checkout. x402 and L402 solve machine-native pay-per-use access over HTTP. MPP provides a rail-agnostic sessions layer for continuous agent micropayments across stablecoins, cards, and Lightning. UCP handles the commerce interaction layer for agent shopping within merchant storefronts. Identity systems like Skyfire, standards like ERC-8004, and card network frameworks from Visa and Mastercard move toward the trust layer that open agent markets will require.
So, the question isn't whether agents will transact, but which infrastructure will make them first-class economic actors.
And the answer won't be a single protocol. It will be the systems that make the whole stack work together.
Frequently asked questions
The following questions address common topics related to agentic commerce, autonomous payments, and the emerging infrastructure that lets AI participate in digital markets.
What is agentic commerce?
Agentic commerce refers to systems that allow AI agents to discover, evaluate, and purchase services autonomously. Instead of humans manually interacting with websites or APIs, software agents can identify the tools they need, pay for access, and execute tasks as part of automated workflows. Agentic commerce is emerging as a key component of the broader agentic economy, where AI systems participate directly in digital markets.
What is the agentic economy?
The agentic economy describes a future digital economy in which autonomous AI agents perform economic activities such as purchasing services, coordinating workflows, and transacting with other agents. In this environment, agents may discover tools, pay for APIs, access datasets, or hire other agents to complete tasks.
How do AI agents make payments?
AI agents can make payments through emerging infrastructure designed for machine-to-machine transactions. Examples include ACP, x402, and identity and payment systems such as Skyfire, which allow agents to generate payment tokens for transactions. These systems let agents buy services as part of automated workflows.
What is the Model Context Protocol (MCP)?
MCP is an open standard introduced by Anthropic in November 2024 that lets AI agents connect to external tools, data sources, and services through a standardized interface. Developers implement MCP once and gain access to any compatible server. It makes tools and services discoverable, accessible, and usable by agents.
What is the Agentic Commerce Protocol (ACP)?
The Agentic Commerce Protocol (ACP) enables AI agents to complete purchases on behalf of users within existing e-commerce systems. The agent handles product discovery and checkout interactions, while the payment itself is processed through traditional merchant infrastructure such as credit cards or payment processors.
What is x402?
x402 is an open payment protocol created by Coinbase that enables machine-native payments over HTTP. It revives the HTTP 402 "Payment Required" status code: a server responds to an unpaid request with payment instructions, the client pays, and the resource is delivered. The x402 Foundation governs the standard.
What is Agent-to-Agent (A2A) commerce?
Agent-to-Agent (A2A) commerce refers to transactions that occur directly between AI agents. For example, one agent might pay another agent to perform a specialized task such as data extraction, analysis, or model inference. A2A commerce is considered an important potential component of the emerging agentic economy.
Can AI agents buy things autonomously?
Although this ecosystem is still developing, AI agents are beginning to purchase digital services autonomously using emerging infrastructure designed for machine transactions. Protocols such as MCP allow agents to discover tools, while systems like ACP, x402, and Skyfire let agents authorize and execute payments.
What are agentic payments?
Agentic payments are mechanisms designed specifically for autonomous AI agents. They allow software agents to send payments programmatically as part of automated workflows. Examples include machine-native payment protocols like x402 and token-based systems that let agents access funds for purchasing digital services.
Why do AI agents need payment systems?
AI agents perform complex tasks that require access to paid digital resources such as APIs, automation tools, or compute services. If they can't purchase these services independently, they must pause and request approval from a human user. Payment systems designed for agents allow these workflows to run autonomously.
What is Business-to-Agent (B2A) commerce?
Business-to-Agent commerce describes transactions where businesses sell services directly to AI agents. Examples include AI agents purchasing API calls, datasets, automation tools, or compute resources as part of automated workflows. B2A commerce is expected to become an important part of the emerging agentic economy.
What is the Universal Commerce Protocol (UCP)?
The Universal Commerce Protocol (UCP) is an open standard developed by Shopify that lets AI agents interact with merchant storefronts in a standardized way. It covers product discovery, cart management, and checkout within Shopify's merchant ecosystem.
What is L402?
L402 is a protocol that gates API access using HTTP 402 and Bitcoin Lightning Network payments. It's mainly used in Bitcoin-native developer tooling and infrastructure.
What is the difference between x402 and L402?
Both protocols use HTTP 402 to request payment before delivering a resource, and both are designed for machine-native, programmatic payments. The key difference is the payment rail: x402 settles via stablecoins (primarily USDC) on Base and Solana; L402 settles over the Bitcoin Lightning Network. x402 has broader current adoption and is designed for general web APIs and AI agent use cases. L402 is more established in Bitcoin-native infrastructure.
How do Visa and Mastercard fit into the agentic economy?
Visa and Mastercard are extending their existing card infrastructure to cover agent-initiated transactions rather than building new rails. Visa's Trusted Agent Protocol lets agents authenticate and transact using verified, tokenized card credentials. Mastercard has announced similar agent commerce capabilities.
What is ERC-8004?
ERC-8004 is an Ethereum standard that provides identity and trust infrastructure for autonomous AI agents. It introduces three on-chain registries – Identity, Reputation, and Validation – so agents can discover each other and establish trust across organizational boundaries without pre-existing relationships.
What is the Machine Payments Protocol (MPP)?
MPP is an open-source standard for machine-native payments co-authored by Stripe and Tempo, launched in March 2026. It defines how agents and services coordinate payments programmatically, supporting recurring payments and a sessions primitive so agents can authorize a spending limit upfront.
