What Are Standards & Protocols in Agentic Commerce?

Standards and protocols are the shared rules that allow AI agents to communicate, transact, and cooperate across systems built by different teams. Without them, every agent would speak its own language, unable to discover services, negotiate prices, or settle payments with agents built by someone else.

In traditional commerce, standards like HTTP, TLS, and credit card networks took decades to emerge. Agentic commerce is compressing that timeline into months. The protocols emerging today will determine how trillions of dollars in machine-to-machine transactions flow over the next decade.

Think of standards as the roads and traffic signals of the agent economy. Individual agents are the cars. Without shared infrastructure, you get gridlock. With it, you get a functioning economy where any agent can transact with any service, on any chain, using any payment method, seamlessly and without human intervention.

The stakes are enormous. The companies and consortia defining these standards today are effectively writing the constitution of the agent economy. Every payment processor, wallet provider, and agent framework will build on top of these protocols. Getting them right (open, composable, and secure) is the difference between an interoperable agent ecosystem and a fragmented landscape of walled gardens.

Why Interoperability Matters for Agents

Human commerce tolerates friction. You can switch between payment apps, copy-paste credit card numbers, or call customer support when something breaks. Agents cannot. An AI agent that hits a payment wall it does not understand simply fails. There is no workaround, no manual override, no frustrated-but-persistent human to push through.

This makes interoperability existential for agentic commerce. If Agent A uses protocol X and Service B requires protocol Y, the transaction does not happen. Multiply this across thousands of agents and services, and you get an economy that cannot function.

Interoperability solves three critical problems:

1. Discovery: how does an agent find a service it needs? Standards like MCP and A2A provide machine-readable interfaces that agents can query programmatically.
2. Negotiation: how do agents agree on terms? Protocols like ACP and AP2 define structured flows for requesting, authorizing, and settling payments.
3. Settlement: how does money actually move? Standards like x402 and ERC-4337 handle the on-chain mechanics of transferring value between agents.

Without interoperability, each agent ecosystem becomes a silo. With it, the entire stack becomes composable: an agent built on Claude can pay a service running on GPT, settled on Base, using USDC, discovered through a Solana-based directory. That composability is what transforms individual agents into an economy.

x402: HTTP-Native Machine Payments

x402 is arguably the most important protocol in agentic commerce today. It brings payments directly into the HTTP layer, the same protocol that powers the web. When an agent requests a resource that requires payment, the server responds with HTTP status code 402 (Payment Required) along with a machine-readable payment request specifying the amount, currency, and accepted payment methods.

The elegance of x402 is its simplicity. It does not require a new network, a new token, or a new infrastructure stack. It works on top of existing HTTP, existing blockchains, and existing stablecoins. An agent receives a 402 response, constructs a payment, attaches proof of payment to the next request, and gets the resource. The entire flow can complete in under a second.

x402 was co-created by Coinbase and has been adopted as the default payment protocol on Base. Cloudflare, a founding member of the x402 Foundation, has integrated the protocol into its edge network, making it possible for any website or API to accept machine payments with minimal code changes. Over 35 million x402 transactions have already been processed on Solana alone.

The protocol supports micropayments natively, including fractions of a cent per API call, per article view, or per compute cycle. This unlocks business models that were impossible with traditional payment rails, where minimum transaction fees make anything under a dollar uneconomical.

ERC-8004: On-Chain Agent Identity

ERC-8004 solves a problem that x402 cannot: who is this agent, and should I trust it? While x402 handles the mechanics of payment, ERC-8004 provides a standard for registering AI agents on-chain with verifiable identity.

The standard defines a registry where agents are associated with their operators (the humans or organizations that deploy them), their capabilities, and their transaction history. When Agent A encounters Agent B for the first time, it can look up B's ERC-8004 registration to verify that B is a legitimate agent operated by a known entity, not a malicious bot impersonating a service.

A common misconception is that ERC-8004 is meant for every AI agent. In practice, the standard is most valuable for service-facing agents: the agents that expose capabilities, accept payments, and need to prove their legitimacy to callers. For a client agent, one that consumes services on behalf of a user, registering an on-chain identity can actually be counterproductive. A publicly indexable identity creates an attack surface. Adversaries can enumerate registered agents, study their capabilities and spending patterns, and craft targeted exploits such as prompt injection payloads tailored to a specific agent's known tool integrations, or phishing services designed to match an agent's declared purchase categories. Client agents are generally better served by ephemeral sessions, scoped API keys, or delegated wallet authorization that keeps them anonymous to the services they interact with.

The takeaway is that ERC-8004 is infrastructure for trust on the supply side. Services need discoverable, verifiable identities so that client agents can evaluate them before transacting. Client agents, by contrast, benefit from being lightweight and hard to fingerprint.

The standard is part of the broader Ethereum improvement process and has been championed by projects building agent identity infrastructure. It works in concert with KYA (Know Your Agent) verification, a framework for establishing what an agent is authorized to do, who it represents, and what constraints govern its behavior.

MCP: Model Context Protocol

MCP (Model Context Protocol) was introduced by Anthropic to standardize how AI models connect to external tools, data sources, and services. Before MCP, every integration between an AI model and an external system was a custom, brittle connection. Each tool provider had its own API format, authentication flow, and data schema.

MCP defines a universal interface. A tool provider implements an MCP server that describes its capabilities in a structured format. An AI agent with MCP support can discover these servers, understand what tools they offer, and invoke them with proper authentication, all without custom integration code.

The impact on agentic commerce is profound. MCP turns every API, database, and service into a potential tool for any AI agent. A commerce agent can discover a flight booking MCP server, understand its capabilities (search flights, compare prices, book tickets), and use it, even if the agent and the server were built by completely different teams.

MCP has been adopted by major model providers and framework builders. Qwen ships with native MCP support. Phantom has built an MCP server for Solana wallet operations. Cloudflare supports MCP for edge-deployed agent tools. The protocol is rapidly becoming the standard way agents discover and use tools.

A2A: Agent-to-Agent Protocol

While MCP handles agent-to-tool communication, A2A (Agent-to-Agent protocol) by Google handles agent-to-agent communication. A2A defines how autonomous agents discover each other, negotiate tasks, exchange information, and coordinate multi-step workflows.

The distinction matters. An agent using MCP to call a weather API is performing a tool invocation, a simple request-response pattern. An agent using A2A to hire another agent for a complex task (research, comparison shopping, report generation) is engaging in a collaborative workflow that may involve multiple rounds of negotiation, partial results, and iterative refinement.

A2A defines Agent Cards, machine-readable descriptions of an agent's capabilities, pricing, and terms of service. When Agent A needs help with a task, it can discover Agent B's Agent Card, evaluate whether B's capabilities match its needs, negotiate terms, and delegate the task. The protocol supports both synchronous and asynchronous workflows, streaming results, and multi-agent coordination.

Google has positioned A2A as a complement to MCP, not a competitor. MCP handles the vertical integration between agents and tools. A2A handles the horizontal coordination between agents. Together, they form the communication backbone of the agent economy.

ACP: Agent Commerce Protocol

ACP (Agent Commerce Protocol) is the commerce-specific protocol co-developed by OpenAI and Stripe. While x402 handles simple pay-per-request micropayments, ACP handles complex, multi-step shopping flows, the kind where an agent browses products, adds items to a cart, applies coupons, selects shipping, and checks out.

ACP defines a structured flow for agent shopping. The agent sends a purchase intent, the merchant responds with available options (products, pricing, shipping methods), the agent selects and configures its order, and the merchant returns a checkout URL or processes the payment directly. The entire flow is machine-readable, so agents can navigate it without parsing HTML or simulating clicks.

Virtuals Protocol has adopted ACP for its agent network, which now hosts over 18,000 agents with a combined aGDP (agent Gross Domestic Product) exceeding $470 million. ACP provides the transactional backbone that allows these agents to buy and sell services from each other.

The protocol represents the convergence of traditional e-commerce infrastructure (Stripe) with AI-native agent capabilities (OpenAI). This combination of established payment rails with frontier AI is what makes ACP particularly powerful: it does not require merchants to adopt new payment methods, just a new interface layer.

AP2: Agent Payment Protocol

AP2 (Agent Payment Protocol) is Google's answer to the agent payments problem. Developed as part of the broader A2A ecosystem, AP2 uses cryptographic mandates to authorize agent payments, a fundamentally different approach from x402's pay-per-request model or ACP's shopping flow model.

With AP2, a human sets up a cryptographic mandate that defines exactly what an agent is allowed to spend: maximum amount, allowed merchants, allowed categories, time window, and other constraints. The agent carries this mandate as a credential. When it needs to make a payment, it presents the mandate to the merchant, who can verify cryptographically that the payment is authorized without contacting the human.

Over 60 organizations have joined the AP2 consortium, including major banks, payment processors, and tech companies. The protocol is designed to work with existing payment infrastructure (credit cards, bank transfers, and digital wallets), not just crypto. This makes it particularly attractive to enterprises that are not ready to adopt blockchain-based payments.

AP2's mandate-based approach addresses a core concern in agent payments: how do you give an agent spending authority without giving it unlimited access to your funds? The cryptographic mandate is the answer. It provides precisely scoped authorization that the agent cannot exceed or modify.

UCP, ERC-4337, and MPP: Completing the Stack

Several additional standards round out the agentic commerce protocol stack.

UCP (Universal Commerce Protocol) aims to be a meta-protocol that bridges the gap between different payment standards. Rather than forcing merchants to support x402 AND ACP AND AP2, UCP provides a universal interface that translates between them. An agent that speaks UCP can transact with any merchant, regardless of which underlying protocol the merchant uses.

ERC-4337 is the account abstraction standard on Ethereum. It replaces traditional externally-owned accounts (EOAs) with smart contract wallets that can execute programmable logic. For agents, this means wallets that can enforce spending policies, batch transactions, pay gas fees in stablecoins instead of ETH, and support session-based authorization, all without requiring the agent to manage private keys directly. Over 40 million smart accounts have been created using ERC-4337, making it the most widely adopted account abstraction standard.

MPP (Machine Payments Protocol) is the newest entrant, co-authored by Stripe and launched with the Tempo blockchain. MPP defines an open standard for agent-to-service payments with features specifically designed for machine commerce: payment sessions for continuous service usage, payment-method agnosticism (crypto, cards, bank transfers), HTTP-based control flow, and a payments directory with over 100 services at launch. Visa, Stripe, and Lightspark provide network extensions for card payments, wallets, and Bitcoin Lightning respectively.

Together with x402, ERC-8004, MCP, A2A, ACP, and AP2, these protocols form a comprehensive (if still evolving) stack for agent commerce. The challenge now is convergence: can the ecosystem coalesce around a manageable set of standards, or will fragmentation slow adoption?

How These Standards Relate to Each Other

The standards landscape can seem overwhelming, but each protocol occupies a distinct layer in the stack.

Each protocol occupies a distinct layer:

• Discovery layer: ERC-8004 provides on-chain service identity that agents can query to find and verify services before transacting. A2A enables agents to discover other agents via machine-readable Agent Cards.
• Integration layer: MCP standardizes how agents connect to external tools and data sources, turning any API into a structured capability an agent can invoke.
• Payment layer: x402 handles simple micropayments, ACP handles complex shopping flows, AP2 handles mandate-authorized payments, and MPP handles continuous machine-to-service payments.
• Infrastructure layer: ERC-4337 provides smart wallets and UCP bridges between payment protocols.

Note that MCP is often described as a discovery protocol, but that is misleading. MCP is really an integration standard. It defines how an agent connects to and uses a tool once the agent already knows about it. Discovery, the act of finding what services and agents exist and whether they are trustworthy, is handled by ERC-8004 (for on-chain service identity) and A2A Agent Cards (for agent-to-agent discovery).

In practice, a single agent transaction might touch multiple protocols. An agent discovers a service via its ERC-8004 registry entry, connects to it via MCP, coordinates with other agents via A2A, authorizes payment via AP2, settles the transaction via x402 on Base using an ERC-4337 smart wallet, and records the interaction for future reference.

The ecosystem is still young enough that no single stack has won. Some builders are betting on the x402 + MCP + Base stack (Coinbase ecosystem). Others are building on ACP + A2A + AP2 (Google/OpenAI/Stripe ecosystem). And the Tempo + MPP stack is emerging as a third major option. Interoperability between these stacks, possibly through UCP, will determine whether the agent economy fragments or unifies.

Key Organizations Building the Standards Layer

The standards and protocols category is unique because the organizations behind it span open-source projects, foundations, consortia, and corporations rather than traditional startups alone.

x402 was created by Coinbase and is maintained by the x402 Foundation, with Cloudflare as a founding member. It has become the de facto standard for HTTP-native micropayments. MCP was created by Anthropic and has been adopted across the industry, including by competitors like Qwen.

A2A was developed by Google as part of its broader agent infrastructure play. ACP is co-developed by OpenAI and Stripe, combining frontier AI capabilities with established payment infrastructure. AP2 is also from Google, focused specifically on cryptographic payment mandates with support from over 60 organizations including Visa. MPP was co-authored by Stripe and launched with the Tempo blockchain, backed by Paradigm.

The Ethereum Foundation plays a central role in several of these standards. ERC-8004 (on-chain agent identity), ERC-4337 (account abstraction), and EIP-8183 (agent authorization) all emerged from the Ethereum improvement process that the foundation stewards. Consensys, a leading Ethereum infrastructure company, has been instrumental in advancing these standards through its developer tooling and enterprise blockchain work, helping bridge the gap between Ethereum-based standards and real-world adoption.

ERC-4337 has been implemented by organizations like Rhinestone (ERC-7579 modular smart accounts), Polygon (Agent CLI toolkit), and major wallet providers, with over 40 million smart accounts deployed. UCP aims to bridge the gaps between all these protocols.

AXTP focuses on secure agent-to-agent communication with cryptographic attestation. Lobster.cash, backed by Visa, Circle, and Solana, provides practical infrastructure for agent virtual debit cards built on top of these foundational standards.

The Future of Standards in Agentic Commerce

The current standards landscape mirrors the early days of the internet, when TCP/IP, HTTP, SMTP, and FTP were competing and converging simultaneously. Some protocols will become foundational. Others will be absorbed into broader standards or fade away.

Three trends will shape the next phase:

1. Consolidation: the ecosystem cannot sustain a dozen competing payment protocols. Expect to see mergers, bridges (like UCP), or de facto winners emerge as transaction volume concentrates on a few protocols.
2. Enterprise adoption: as major corporations like Visa, Mastercard, and Stripe commit to specific standards (AP2, ACP, MPP), those standards gain legitimacy and momentum that open-source alternatives struggle to match.
3. Regulatory attention: as agent transactions grow from millions to billions of dollars, regulators will demand that standards include compliance hooks such as KYC/AML verification, transaction limits, audit trails, and dispute resolution.

The most likely outcome is not a single winning protocol but a layered stack where different standards handle different parts of the transaction lifecycle, connected by interoperability layers. The winners will be the protocols that are open enough to attract broad adoption, specific enough to solve real problems, and flexible enough to evolve as the agent economy matures.

For builders entering the space today, the practical advice is: start with x402 + MCP as the minimum viable stack, add A2A if you need agent coordination, and watch MPP closely as Tempo gains traction. The standards are still being written, and the teams building on them today have an outsized influence on what the agent economy becomes.