What the agent economy is, which protocols are shaping it, and how they fit together into a unified stack
The agent economy is an ecosystem where AI agents act not merely as assistants, but as independent participants: they buy, sell, delegate work to other agents, pay for API access, and sign digital mandates on behalf of users.
Adobe Analytics reported a 4700% year-over-year increase in agent-driven traffic to US retail websites — which is hardly surprising, considering that this type of traffic barely existed a few years ago.
At the same time, the x402 payment protocol processed around 170 million agent transactions worth more than $50 million during its first year, while MPP (Machine Payments Protocol), released at the end of March 2026, handled more than 500 thousand transactions in just two months.
For this entire system to function, shared rules are required. That is exactly what modern agent interaction protocols provide. Their names sound confusingly similar — MCP, MPP, x402, ACP, A2A, AP2, APP, ANP — yet they solve very different problems.
In this article, I’ve collected the major actively evolving protocols and tried to break the landscape down into understandable layers.
Stack Overview
Before diving into the details, it helps to look at the bigger picture.
For the agent economy to truly work, several core problems need to be solved:
- Interaction — how agents communicate with each other, services, and the outside world
- Commerce — how an agent places purchases, orders, and deals
- Payments — how agents send and receive money
- Discovery — how agents and services find each other
- Trust and identity — how to verify who an agent is and what permissions it has
- Confirmation and control — how humans stay involved when consent or verification is required
The modern agent economy stack is now forming around these exact challenges.
Modern agent infrastructure is essentially a layered stack where each layer is responsible for a different piece of the system:
| Layer | What it solves | Main players |
|---|---|---|
| Tools and data | Agents connect to APIs, files, and databases | MCP |
| Agent ↔ agent | Agents communicate and delegate work | A2A, ANP |
| Commerce | Purchases, carts, checkout | ACP, UCP |
| Payments | Actual money movement | x402, MPP, AP2, APP |
| Discovery | How agents find each other | Bazaar, DNS-AID, DUADP |
| Trust and identity | Who the agent is and what it is allowed to do | Verifiable Intent, Visa TAP |
| Onchain standards | Trust, but on blockchain rails | ERC-8004, ERC-8183, ERC-7662 |
| Human interface | UI for agents | AG-UI, A2UI |
How agents interact with the world: communication protocols
MCP — Model Context Protocol
An open standard from Anthropic that allows AI agents to connect to external tools, data sources, and services through a unified interface. In short, it is “USB‑C for agents.” It defines how agents access data and perform actions.
MCP has confidently become an industry standard: millions of SDK downloads, large server catalogs, and support from Anthropic, OpenAI, Google, and Microsoft.
In December 2025, Anthropic transferred governance of the protocol to the Linux Foundation (Agentic AI Foundation).
Pros: mature ecosystem, thousands of ready-to-use servers, genuine industry consensus.
A2A — Agent2Agent
A protocol from Google designed for communication between agents: they discover one another, exchange capabilities (through Agent Cards — essentially business cards for agents), delegate tasks, and coordinate workflows.
If MCP represents the “hands” of an agent, A2A represents its “social skills.” The idea is to allow agents from different vendors to work together.
A2A has become the leading standard for inter-agent coordination, backed by dozens of enterprise partners. At the end of 2025, IBM’s competing ACP protocol formally merged into A2A under the Linux Foundation umbrella.
Pros: broad support, a clear Agent Card capability model, naturally complements MCP.
Cons: optimized for enterprise environments; may be excessive for highly open or decentralized agent networks.
ANP — Agent Network Protocol
A more ambitious attempt to build an open agent network.
It is an alternative “internet of agents” stack covering not only communication, but also identity, encryption, agent descriptions, and discovery. It attempts to be an all-in-one framework.
Pros: philosophically closer to the open web, without strong dependence on large corporate players.
Cons: less mature than A2A; the ecosystem is still relatively small.
Commerce: how agents make purchases
Here it makes sense to separate two layers.
Checkout — “adding items to a cart and placing an order.”
Payments — “how money moves and how payment is confirmed.”
ACP — Agentic Commerce Protocol
An open standard from OpenAI and Stripe describing how an agent communicates with merchants: product feeds, cart creation, checkout, and capability negotiation. It is essentially the “language” your shopping agent uses to interact with any store.
It launched into production in early 2026 through ChatGPT Instant Checkout. Partners include Stripe, Shopify, Salesforce, and PayPal.
Pros: real transactions are already happening; straightforward Shared Payment Token model (a one-time token with limits and expiration, where the merchant only sees the necessary information).
Cons: ACP itself does not handle payments and adoption is still relatively limited.
UCP — Universal Commerce Protocol
A broader protocol from Google covering the full commerce lifecycle: store discovery, purchases, checkout, and post-sale support.
Its primary partner is Shopify.
Status. Announced in January 2026, launched with more than 20 partners and deep integration with Google Shopping and AI Overviews.
Pros: broader scope than ACP; native integration with the Google ecosystem.
Cons: most likely optimized for large retailers.
Payments
x402
An HTTP-native payment standard from Coinbase that revives the long-forgotten 402 Payment Required status code.
The logic is simple: an agent calls an API, the server responds with “payment required” plus instructions (amount, currency, wallet), the agent signs a stablecoin payment, and receives the resource. No accounts, API keys, or subscriptions required.
x402 processed more than 165 million transactions. V2 launched in December 2025 with multi-chain support and dynamic recipients. Stripe integrated x402 for USDC on Base in February 2026, and Cloudflare added support for x402 transactions. The x402 Foundation was launched together with Cloudflare in September 2025.
Pros: fast API payments based on actual usage without subscriptions, zero friction for machines, naturally works without human involvement, excellent documentation and developer tooling.
Cons: limited to stablecoins and crypto rails; for the traditional enterprise world, this is still perceived as “new and unfamiliar.”
MPP — Machine Payments Protocol
A machine payments protocol from Stripe and Tempo Blockchain. A more enterprise-oriented and universal protocol.
If x402 is simultaneously both a protocol and a payment method, MPP looks more like a fully standardized enterprise-grade framework. MPP does not define how or what to pay with. Instead, it defines the rules governing payment and verification. Put simply: if a payment flow can be expressed in MPP terms, it can work regardless of whether the underlying payment method is cards or crypto.
Mainnet launched on March 18, 2026, with more than 100 integrated services from day one. Partners include Stripe, Visa, Mastercard, Lightspark, Anthropic, OpenAI, and Shopify. It offers 0.5-second finality and does not require a gas token.
Pros: works with both crypto and fiat, more universal than x402, compliance-friendly, enterprise-focused.
Cons: more complex to implement — the cost of universality.
APP — Agent Payments Protocol (by OKX)
A payment standard from OKX built on top of x402 and MPP. It supports four payment models: one-time payments, multiple payments within a single request, pay-as-you-go, and escrow.
Its goal is essentially to combine the capabilities of x402 and MPP.
Pros: multiple payment models, compatible with both x402 and MPP.
Cons: more complex than x402 or MPP, still extremely early-stage, may be excessive for simple API payment use cases.
AP2 — Agent Payments Protocol (by Google)
A payment authorization protocol from Google developed together with partners. AP2 is not a payment rail itself, but rather a consent layer: users sign cryptographic “mandates” (Intent, Cart, Payment) that specify exactly what an agent is allowed to purchase, within what limits, and during what time window. These mandates are then attached to transactions and can serve as evidence in disputes.
The specification has already been published, and the A2A x402 extension is production-ready.
Pros: addresses one of the biggest problems in agent commerce — “did the user actually authorize this?”. Supports multiple rails: cards, banks, stablecoins, x402.
Cons: complex ecosystem and trust model; currently feels more like a framework than a mature production standard.
Discovery: how agents find each other
Agents can simply be given direct links to MCP servers, APIs, or other agents. That is the traditional approach. But agents become much more flexible and autonomous when they can independently discover whatever they need in order to complete a task.
That is exactly what the discovery layer is for.
x402 Bazaar
This is an extension of the x402 protocol that enables catalogs of paid x402-compatible services. If you operate a paid API, Bazaar is what allows agents to discover you.
x402 relies on a facilitator responsible for sending transactions to the blockchain and confirming them. A facilitator may work with many servers simultaneously, meaning it can be aware of the paid endpoints those servers expose.
Bazaar allows facilitators to index server endpoints, payment flows they process, semantic descriptions, and payment metadata derived from onchain activity.
At the moment, this is probably the most practical discovery layer for machine payments.
x402 DNS Discovery
Separately worth mentioning is x402 DNS Discovery. Besides Bazaar, x402 also includes a draft discovery mechanism based on DNS TXT records: domains publish _x402 records containing URLs to manifests and metadata for x402-compatible resources. This is a lower-level mechanism compared to Bazaar.
MPP Discovery
A discovery extension for Machine Payments Protocol. Services publish OpenAPI 3.1 documents containing payment metadata: which endpoints are paid, their prices, supported payment methods, currencies, and intents.
MPP also provides a live services catalog at mpp.dev/services, along with MPPScan as a registry/aggregator for services exposing discovery documents.
UCP Discovery
Provides similar functionality, but in the commerce domain: agents can discover what business capabilities a merchant supports, which payment options are available, and which actions can be performed through a UCP profile.
A2A Agent Card
The basic discovery mechanism in Agent2Agent. Agents publish JSON cards describing their capabilities, endpoints, authentication requirements, and supported operating modes. It is not a marketplace, but more like a digital business card that helps another agent decide whether interaction makes sense.
MCP Registry
A catalog of MCP servers. This acts as discovery infrastructure for tools and servers that agents can connect to. In practice, agents often need to discover tools and infrastructure rather than other agents: GitHub, Postgres, browser automation, payments, search, and so on.
Exotic Discovery Protocols
These are various approaches for discovering agents across the open internet and local networks:
- LAD-A2A — local discovery of A2A agents in office or home networks using mDNS, DNS-SD, well-known endpoints, DHCP, QR/NFC.
- DNS-AID — discovery through DNS. Agents publish endpoints and metadata in DNS records, allowing other agents to find them using the existing internet infrastructure.
- ANS — Agent Name Service — closer to identity and naming than pure discovery. If DNS-AID answers “where is the agent and what can it do?”, ANS answers “who is this agent and can it be trusted?”.
- DUADP — Decentralized Universal AI Discovery Protocol, a federated attempt to create “DNS for AI agents” without a single centralized intermediary.
Manifests and the agent-friendly web
llms.txt— a lightweight file similar to robots.txt that explains to agents how to interpret a website and where to obtain clean context.- Agent Ready Web / ARW — a more structured approach using
/llms.txt, markdown views, OAuth, Schema.org, and other components to make websites not only readable, but also actionable for agents. - WebMCP — an approach where websites expose structured tools directly consumable by agents instead of forcing them to infer actions from UI interactions.
- OAI-1 / Open Agent Identity — an attempt to combine discovery, identity, manifests, and interaction models into a single standard.
Trust: who this agent is and what it is allowed to do
This is arguably the most sensitive layer. When an autonomous agent makes a $5000 purchase without your knowledge — who is responsible? How does a merchant distinguish a legitimate agent from a botnet? How are disputes resolved? These are the problems trust protocols aim to solve.
Verifiable Intent (Mastercard + Google)
An open cryptographic framework that creates tamper-proof proof of user authorization for every agent transaction. It links consumer identity, instructions given to the agent, and transaction results into a single cryptographic “witness” that all parties can present in the event of a dispute.
Announced on March 5, 2026, with open-source implementation available at verifiableintent.dev. It is expected to become part of Mastercard Agent Pay. Compatible with AP2, UCP, and ACP.
Pros: selective disclosure (merchants only see exactly what they need and nothing more); solves dispute resolution problems; built on well-established standards.
Cons: requires agent operators to be registered entities with formal relationships with Mastercard, limiting anonymous and decentralized scenarios.
Visa Trusted Agent Protocol (TAP)
An alternative approach from Visa: instead of maintaining long chains of cryptographic witnesses, TAP signs agent identity directly inside HTTP request headers. Merchants verify the signature through Visa’s directory and immediately know they are dealing with a legitimate agent.
Launched together with Cloudflare on October 14, 2025.
Verifiable Intent (VI) vs Visa TAP
Put simply, VI is a persistent proof chain designed for dispute resolution after a session ends. TAP is an HTTP-boundary signature, designed to help merchants instantly determine whether a request comes from a legitimate agent or not.
They operate at different layers of the stack and optimize for different use cases.
Other standards
There are many additional standards that are useful for agent interaction, although they were created before the rise of agents — and sometimes before modern AI itself.
There is no need to go too deeply into them here, since they were designed for much broader purposes, but notable examples include:
- DIDs (Decentralized Identifiers) — a standard for decentralized digital identities.
- Verifiable Credentials (VC) — a standard for issuing and cryptographically verifying digital credentials.
- OpenID4VP (OpenID for Verifiable Presentations) — a standard for presenting and transferring verifiable credentials.
- OpenID Federation — a trust framework between identity providers and services using signed metadata and trust chains.
- OAuth RAR (Rich Authorization Requests) — an OAuth 2.0 extension for structured and detailed access-right descriptions.
- DPoP (Demonstration of Proof-of-Possession) — an OAuth 2.0 mechanism that binds access tokens to client cryptographic keys and protects against token theft.
User interfaces: AG-UI and A2UI
The paradox of “autonomous” agents is that humans are still periodically required — to approve purchases, select options, or interrupt actions. UI protocols exist to handle exactly this interaction layer.
AG-UI
An event-based protocol from CopilotKit that connects user frontends with agent backends. It streams events, state updates, progress, and approval requests — all in real time.
Modern agents can spend minutes reasoning, invoking tools, and requesting permissions.
AG-UI is effectively the “wire” through which all of this flows into the interface.
A2UI
A declarative protocol from Google for generative UI: the agent describes which components should be displayed (cards, forms, buttons), while the frontend renders them. No iframe sandboxes and no arbitrary code execution.
A2UI v0.9 launched in April 2026 with prompt-first generation, bidirectional messaging, and Agent SDK support.
AG-UI vs A2UI
These protocols are not competitors.
A2UI defines WHAT should be displayed.
AG-UI defines HOW it should be delivered.
They integrate naturally: A2UI payloads are transmitted through AG-UI events. Together they form a complete stack for agent-driven user interfaces.
Ethereum onchain standards for agents
If you want agents to be fully decentralized, without relying on Stripe, Visa, Google, or OpenAI, then onchain standards become highly relevant.
ERC-8004: Trustless Agents
A standard for onchain agent identity. Each agent has a public onchain ID, an NFT pointing to an Agent Card (name, capabilities, MCP/A2A endpoints, payment address), and three registries: identity, reputation, and validation.
It launched on Ethereum mainnet on January 29, 2026. More than 10,000 agents registered during the five months of testnet.
Pros: decentralization.
Cons: there is no guarantee that reputation scores are not artificially inflated.
ERC-8126 and ERC-8122
ERC-8126 — a verification interface for agents registered through ERC-8004, including standardized trust scores.
ERC-8122 — a lightweight registry for deploying custom or curated agent lists, useful for L2 ecosystems or niche communities.
ERC-8183: Agentic Commerce
A task escrow standard: users lock funds, agents complete work, evaluators confirm results, and funds are released. Entirely auditable payouts.
This standard is particularly useful for paid agent services, task marketplaces, and scenarios where “funds remain locked until work is confirmed.”
ERC-8033: Agent Council Oracles
An oracle interface where requests are resolved by a “council” of agents. If a semantic question must be answered (“is statement X true?”), multiple agents are queried and their responses aggregated.
Agents as NFTs: ERC-7662, ERC-7857, ERC-8041
- ERC-7662 — an NFT representing an AI agent with agent-specific metadata. Tradable and transferable.
- ERC-7857 — a similar concept, but with private metadata embedded as part of the asset (for example, private model weights or secret keys).
- ERC-8041 — collections of agent NFTs with a fixed number of agents.
Implementation extensions
These are not complete standalone protocols, but they are extremely important in real-world development:
- Shared Payment Tokens (Stripe) — one-time tokens tied to a specific merchant and amount with TTL. Agents can pay using the token without access to the actual card.
- x402 Sign-In-With-X (SIWX) — an extension for reusing authorization without re-signing every request.
- x402 Payment-Identifier — payment idempotency support to prevent accidental double payments during network failures.
Where this is all heading
Which protocols will ultimately survive and which ones the market will recognize as the most universal remains an open question. The agent economy is evolving extremely quickly — most of these protocols appeared within just the last six to twelve months.
Agent economies and agent interaction are now being discussed across the entire industry. Even more autonomous tools such as Openclaw and Hermes are emerging and attracting attention with their capabilities.
At first glance, all of these protocols look chaotic, but in reality they are forming fairly clean layers. MCP leads in tooling, A2A in coordination, x402 in machine payments, and AP2 in authorization.
And importantly, these systems are not emerging from niche communities of hobbyists or solo developers, but from major industry players such as Google, Visa, Stripe, OpenAI, and Shopify. At the very least, this signals serious long-term interest in agents and the broader agent economy — even if the hype eventually fades.