AI Atlas
All guides
🧭 GUIDE

MCP, A2A, AP2 and Friends: A Map of Agent Protocols

A layer-by-layer map of agent protocols: MCP (agent ↔ tools/data), A2A (agent ↔ agent, Agent Cards), and the payment and commerce protocols (AP2, x402, ACP, UCP, Visa Trusted Agent Protocol); who maintains each, current version and status, how they stack in a real shopping flow, the security and consent model with mandates and signed cards, when you need which, and an FAQ.

Updated:

MCP A2A AP2 x402 Agentic Commerce Protocol

Summary

The things discussed under the label "agent protocol" actually solve different layers. MCP connects an agent to tools and data. A2A connects two independent agents to each other. AP2, x402, ACP, UCP and Visa's Trusted Agent Protocol try to standardize the moment an agent spends money or shops with a merchant; we group these as agent payments.

This guide asks the same questions of every protocol: which layer does it solve, who maintains it, what is the current version and status, and what is its security model based on. Then it stacks them all in a single shopping flow and explains when you need which.

Note: Everything here was checked on November 8, 2026 against the protocols' own specification repos (including GitHub release tags) and official announcements from the maintainers (Linux Foundation, Agentic AI Foundation, Anthropic, Google, Coinbase, OpenAI, Visa, Cloudflare). This space moves very fast; version numbers can go stale within months. Claims that are a vendor's own are attributed ("according to X"). We give no adoption numbers; supporter counts appear only with their source.

The map, layer by layer

Protocol Which layer? Maintainer / governance Current version (Nov 2026) Status
MCP Agent ↔ tools and data Agentic AI Foundation (Linux Foundation); started by Anthropic 2026-07-28 Stable, date-based revisions
A2A Agent ↔ agent Agentic AI Foundation (Linux Foundation); started by Google v1.0.1 (spec 1.0) Stable (1.0, March 2026)
AP2 Payment authorization (mandates) Donated to the FIDO Alliance; started by Google v0.2.0 Early (0.x)
x402 Payment over HTTP x402 Foundation (Linux Foundation); born at Coinbase Protocol version 2 Active development
ACP (Agentic Commerce Protocol) AI surface ↔ merchant checkout + delegated payment OpenAI and Stripe 2026-04-17 Beta
UCP AI surface ↔ merchant commerce (discovery, checkout, orders) Google + partners (Shopping Tech Council) 2026-08-25 Active development
Visa TAP Agent identity and intent (merchant-side verification) Visa (with Cloudflare) No version tag Spec + sample implementation

Roughly three floors: a context layer (MCP), a collaboration layer (A2A) and a commerce/payment layer (ACP and UCP carry the shopping itself, AP2 and x402 carry payment authorization and payment, TAP carries the agent's identity). The Agentic AI Foundation's own post separates MCP as "agent to tool connectivity" and A2A as "agent to agent interoperability" the same way.

MCP: the agent's tools and data

MCP (Model Context Protocol) defines how a client inside an LLM application (the host) connects over JSON-RPC 2.0 to servers that expose tools, resources and prompt templates. Anthropic announced it in November 2024; today Claude, ChatGPT, Cursor, VS Code and many other clients support it. For details see the MCP Server Catalog and Build Your Own MCP Server guides.

Who runs it? On December 9, 2025 Anthropic donated MCP to the Agentic AI Foundation (AAIF), set up as a directed fund under the Linux Foundation. According to the MCP blog, AAIF was co-founded by Anthropic, Block and OpenAI, with support from Google, Microsoft, AWS, Cloudflare and Bloomberg. The same post says the AAIF governing board decides strategic matters such as budget and new projects, while projects like MCP keep full autonomy over their technical direction; MCP's maintainer structure did not change.

Current version: The spec is versioned by date. The latest is 2026-07-28 (its release candidate shipped on May 29, 2026); the previous one is 2025-11-25. The 2026-07-28 revision makes MCP largely stateless. According to the changelog:

  • The initialize handshake and the Mcp-Session-Id header in Streamable HTTP are gone; every request carries its protocol version and client capabilities in _meta.
  • A new server/discover call lets servers advertise their supported versions and capabilities.
  • Server-initiated requests (sampling/createMessage, elicitation/create, roots/list) are replaced by the Multi Round-Trip Requests pattern: the server returns an interim result of type input_required, and the client completes the request with the missing information.
  • The experimental tasks feature moved out of the core into an official extension (io.modelcontextprotocol/tasks).
  • On authorization, if the authorization response includes an iss parameter, the client must validate it against the recorded issuer (RFC 9207).

A server written against an older SDK can be affected by these changes; check which spec revision your SDK supports.

Security model: Authorization for remote MCP servers is OAuth-based. But the real risk is not in the protocol, it is in the server's permissions: an MCP server runs with whatever account you give it, and because tool descriptions and tool outputs enter the model as text, it also opens a path for prompt injection. Least privilege and an approval step apply here too.

A2A: agent to agent

A2A (Agent2Agent) defines how "opaque" agents, built with different frameworks at different companies, hand work to each other. "Opaque" matters: the client agent does not see the other agent's internals, memory or tools; it only sees the skills it advertises and the result of the task.

Who runs it? Google announced it in April 2025. On June 23, 2025 the Linux Foundation announced it was taking A2A on as a project; Google donated the spec, SDKs and tooling. In August 2025 IBM Research's Agent Communication Protocol (ACP; see the naming collision below) merged into A2A; according to the LF AI & Data announcement, the ACP team wound down independent development and started contributing to A2A. On August 17, 2026 A2A joined the Agentic AI Foundation as a hosted project; according to AAIF, more than 150 organizations back A2A.

Current version: v1.0.0 shipped on March 12, 2026 and the v1.0.1 patch on May 28, 2026 (the previous major was 0.3.0, July 2025). The 1.0 release notes contain breaking changes: the application protocol was separated from the transport bindings, OAuth implicit/password flows were removed in favor of device code and PKCE, and tasks/list was added. An integration written against 0.3 should check field names when moving to 1.0.

How it works:

  • Agent Card: The agent's ID card. Per the spec, clients find it at https://{server_domain}/.well-known/agent-card.json, through a registry, or via direct configuration. The card contains the name, the provider, supportedInterfaces (URL + JSONRPC, GRPC or HTTP+JSON binding + protocol version), capabilities (streaming, push notifications), the skills list and the securitySchemes / securityRequirements fields.
  • Task: The unit of work. The client sends a message with SendMessage (or SendStreamingMessage); long-running work becomes a task. Task states are submitted, working, input-required, auth-required, completed, failed, canceled, rejected. input-required and auth-required are the standard way for the remote agent to ask for information or authorization mid-flight.
  • Message, Part, Artifact: Messages carry text, file or structured-data parts; the task's output comes back as artifacts.
  • Extended Agent Card: A second card that shows more skills to an authenticated client. Information missing from the public card is visible only to authorized clients.
{
  "name": "Travel Planning Agent",
  "description": "Compares flight and hotel options and suggests bookings.",
  "supportedInterfaces": [
    { "url": "https://travel.example.com/a2a/v1", "protocolBinding": "JSONRPC", "protocolVersion": "1.0" }
  ],
  "provider": { "organization": "Example Travel", "url": "https://example.com" },
  "version": "2.1.0",
  "capabilities": { "streaming": true, "pushNotifications": false },
  "securitySchemes": {
    "oidc": { "openIdConnectSecurityScheme": { "openIdConnectUrl": "https://id.example.com/.well-known/openid-configuration" } }
  },
  "securityRequirements": [{ "schemes": { "oidc": { "list": ["openid"] } } }],
  "defaultInputModes": ["text/plain"],
  "defaultOutputModes": ["application/json"],
  "skills": [
    { "id": "compare-flights", "name": "Flight comparison", "description": "Ranks flights between two cities by price and duration.", "tags": ["travel", "flights"] }
  ]
}

Signed cards: Per the spec, an Agent Card MAY be signed with JWS (RFC 7515); before signing, the content MUST be canonicalized with the JSON Canonicalization Scheme (RFC 8785). Clients SHOULD verify at least one signature before trusting a card, and expired or revoked keys MUST NOT be used. A signature proves the card really comes from the claimed provider and was not tampered with in transit; it does not prove the agent is honest.

The A2A docs' own summary is useful: MCP is vertical (it deepens a single agent by giving it new tools), A2A is horizontal (it connects the agent to agents beyond its own boundary). The same agent can be both an MCP client and an A2A server.

The payment and commerce layer

When an agent wants to buy something, three separate questions come up: (1) In what language do the merchant and the agent talk about products, carts and checkout? (2) How do you prove the user really approved this spend? (3) How does the merchant know the agent at its door is not a malicious bot? The protocols below answer different combinations of these questions.

AP2 (Agent Payments Protocol)

What it solves: Question 2. It turns the user's intent and approval into cryptographically signed, non-repudiable records.

Who runs it, and what is its status? Google announced it on September 16, 2025 together with payments and technology companies (v0.1.0). On April 28, 2026 Google announced it was donating AP2 to the FIDO Alliance and released v0.2 the same day; v0.2 focuses on "Human Not Present" flows, where the user is not there at the moment of purchase. According to the AP2 docs, spec work will continue in FIDO's Agentic Authentication and Payments technical working groups; the GitHub repo keeps hosting the samples and SDK.

Mandates: AP2's trust rests on verifiable digital credentials (VDCs). The v0.2 docs define two mandate types, each with two stages:

  • Checkout Mandate: Records the items and purchase details agreed with the merchant, and is shared with the merchant. Its Open stage carries constraints before a cart is finalized (e.g. "buy if it is under this price"); its Closed stage is the authorization of a specific, finalized checkout.
  • Payment Mandate: Authorizes payment against a specific payment instrument, and is shared with the credential provider, the network and the merchant's payment processor. Its Open stage carries constraints such as budget and allowed instruments; its Closed stage authorizes an amount bound to a finalized checkout.

The September 2025 announcement and v0.1 used the names Intent Mandate, Cart Mandate and Payment Mandate. If an older blog post uses that trio, it is describing v0.1.

An extension of which protocol? Secondary sources disagree here, and AP2's own docs are not consistent either. The home page introduces AP2 as "an extension for A2A and the Universal Commerce Protocol", the principles section of the same page says "an open extension for A2A and MCP", and the overview document lists A2A, MCP and UCP together. The samples run over A2A; UCP has an AP2 integration guide. For crypto payments, Google released an A2A x402 extension with Coinbase and others.

x402

What it solves: The payment itself, directly inside the HTTP request. Pay per request (e.g. a few cents for an API call or an article) without creating an account or getting an API key.

Who runs it, and what is its status? It was developed at Coinbase. According to Coinbase's docs, the x402 Foundation launched under the Linux Foundation on April 2, 2026 and Coinbase completed its contribution of the protocol; the main repo is now x402-foundation/x402, with coinbase/x402 as a development fork. The current spec is protocol version 2 (x402Version: 2).

Flow (HTTP, v2):

  1. The client requests a resource.
  2. The server returns 402 Payment Required; the payment requirements (PaymentRequirements: scheme, network, amount, recipient) arrive base64-encoded in the PAYMENT-REQUIRED header.
  3. The client picks one of the requirements, builds a signed PaymentPayload and retries the request with a PAYMENT-SIGNATURE header.
  4. The server verifies the payment itself or through a facilitator's /verify endpoint, does the work, and settles the payment via /settle.

The spec separates payment schemes (exact, upto, batch-settlement) from transport; besides HTTP, there are separate transport documents for MCP and A2A. The README says it aims to support "all networks (both crypto & fiat)"; today's SDK packages are mostly for blockchain networks.

ACP (Agentic Commerce Protocol)

What it solves: Question 1 and part of question 2. An AI surface (e.g. ChatGPT) running a merchant's checkout, and payment credentials passed securely to the merchant's payment provider.

Who runs it, and what is its status? According to the repo, the spec's founding maintainers are OpenAI and Stripe, and its status is beta. Versions are date-based; the first release was 2025-09-29, the latest is 2026-04-17 (cart, feeds, orders, authentication and MCP). It has two main parts: Agentic Checkout (the checkout API the merchant implements) and Delegated Payment (the API the payment provider implements, which tokenizes a card for limited use). The allowance object in Delegated Payment carries the token's limits: reason (e.g. one_time), max_amount, expires_at. According to OpenAI's developer docs, integration on the ChatGPT side starts with a product feed and is currently open to approved partners.

UCP (Universal Commerce Protocol)

What it solves: Question 1, with a wider scope: discovery, checkout, identity linking and post-purchase.

Who runs it, and what is its status? Google announced it on January 11, 2026; according to Google it was co-developed with Shopify, Etsy, Wayfair, Target and Walmart. The Shopping Tech Council in the maintainers list includes people from Google, Shopify, Etsy, Meta, Amazon, Target, Microsoft, Stripe, Salesforce and Wayfair. Versions are date-based; the latest release tag is v2026-08-25.

How it works: The merchant declares its supported capabilities (Checkout, Identity Linking, Order, Payment Token Exchange) and extensions (e.g. discounts, fulfillment) in a profile at /.well-known/ucp; the platform computes the intersection with its own profile and starts the conversation. It is transport-agnostic: REST, MCP or A2A. Identity linking uses OAuth 2.0. AP2 can be used inside UCP as the payment extension. The AP2 FAQ puts the split this way: UCP orchestrates the full purchase lifecycle, while AP2 is the payment layer that authorizes and signs the transaction.

Visa Trusted Agent Protocol (TAP)

What it solves: Question 3. Letting a merchant verify that an incoming agent is registered, recognized and authorized to act for a specific user.

Who runs it, and what is its status? Visa released it in October 2025 together with Cloudflare. There is a sample implementation on GitHub (agent, merchant frontend and backend, CDN proxy, agent registry); the spec lives on Visa's developer site. The repo has no version tags and was last updated in October 2025.

How it works: According to Cloudflare's post, TAP builds on Cloudflare's Web Bot Auth proposal: the agent signs every HTTP request with HTTP Message Signatures (RFC 9421) using an Ed25519 key. The Signature-Input header carries created / expires timestamps, a single-use nonce (against replay), a keyid and a tag stating the agent's purpose: agent-browser-auth when browsing, agent-payer-auth when paying. The agent's public key sits in a Visa-hosted directory. The signature is bound to the merchant's domain and page, so it cannot be reused on another site. According to Cloudflare, Mastercard's Agent Pay uses the same Web Bot Auth foundation.

How they stack in a real flow

Scenario: a user tells their personal assistant, "Set up a two-day business trip to Izmir next month, and keep the total under 15,000 TL." Each protocol kicks in at a different step (this is an illustrative scenario; real products may implement only some of these steps):

  1. MCP: The assistant reads the user's calendar and the company travel policy through MCP servers. No payment here; only context.
  2. A2A: The assistant finds a travel company's agent via /.well-known/agent-card.json, verifies the card's signature, authenticates with OIDC and delegates the task "suggest flight + hotel" with SendMessage. While preparing options, the travel agent moves the task to input-required and asks "window seat?".
  3. AP2 (Open mandates): The user signs the constraints "do not exceed 15,000 TL, corporate card only" in advance. This is the proof of the limits within which the assistant may act even when the user is not present.
  4. UCP or ACP: The travel company's hotel partner exposes its checkout through UCP (or ACP, if the flow happens inside ChatGPT). The cart is finalized.
  5. AP2 (Closed mandates): Closed Checkout and Payment Mandates are created for the finalized cart and amount; the merchant and the payment network each see their own.
  6. Visa TAP: If the assistant transacts directly on a hotel's website, it sends each request with an HTTP signature tagged agent-payer-auth; the hotel's CDN recognizes it as a registered Visa agent.
  7. x402: In the same flow, when the assistant calls a paid weather or flight-delay API, the server returns 402; the assistant signs a payment of a few cents and retries.

The point to notice: no protocol does "everything". ACP and UCP compete at the same layer; AP2 and ACP's Delegated Payment solve payment authorization in different ways (one with signed mandates, the other with a limited-use token).

Protocol How is identity proven? How is user consent carried?
MCP OAuth-based authorization for remote servers Not in the protocol; in the host app's approval UI
A2A Schemes declared in the Agent Card (OIDC, OAuth 2.0, etc.); optional JWS-signed card The task moves to auth-required / input-required
AP2 Verifiable digital credentials Signed Checkout and Payment Mandates (Open → Closed)
x402 Signed payment payload The payment payload itself; budget management is out of the spec's scope
ACP API authentication between merchant and payment provider A one-time payment token limited by allowance
UCP Identity linking via OAuth 2.0; profile discovery Checkout capability; AP2 mandates for autonomous flows
Visa TAP RFC 9421 HTTP signature, key in Visa's directory The purpose tag in the signature and user identifiers

The practical lessons from this table:

  • A signature proves identity, not intent. A signed Agent Card authenticates the card's owner; it does not guarantee the agent will not harm your user. Text coming from a remote agent, like an MCP tool output, can carry prompt injection.
  • In x402, the budget is your problem. The spec explicitly leaves client-side budget management out of scope. If you give a pay-per-request agent no spending cap, allowed-domain list and logging, an agent stuck in a loop can drain the wallet.
  • "Human not present" is the riskiest mode. AP2 v0.2's Open mandates exist for exactly this case: the user signs the constraints in advance. Keep the constraints narrow (amount, time window, merchant, product type) and keep a human-in-the-loop approval for large amounts.
  • Keep the records. Mandates and signed requests are an audit trail showing who approved what if there is a dispute. If you do not store them, you throw away the protocol's biggest benefit.

When do you need which?

  • Your agent will use its own tools and data: MCP. If you are working in a single app for a single model, the model's native function calling is enough.
  • You will delegate work to another team's, company's or product's agent: A2A. For subagents within the same codebase, A2A is overkill; that is solved inside the harness.
  • You want to sell products to agents: The protocol of the surface you want to sell on: ACP for ChatGPT, UCP for Google AI Mode and Gemini. Implementing both is possible.
  • You want to charge per request for your API or content: x402.
  • Your agent will pay on the user's behalf while the user is away: AP2 mandates (or the delegated payment mechanism of the commerce protocol you use).
  • You want to tell shopping agents apart from malicious bots on your site: Visa TAP / Mastercard Agent Pay and the Web Bot Auth beneath them; in practice usually through your CDN or bot management provider.
  • You are building an agent that clicks through a screen: Most of these protocols target the "API" world; for agents that operate a screen see the Computer Use Agents guide.

Naming collision: two different ACPs

The acronym "ACP" has been used for two separate protocols:

  • Agent Communication Protocol: An agent-to-agent protocol that IBM Research started in March 2025 for its BeeAI platform. It merged into A2A in August 2025 and its independent development stopped.
  • Agentic Commerce Protocol: The commerce protocol from OpenAI and Stripe. This is what "ACP" means in this guide.

Most "MCP vs A2A vs ACP" comparisons from 2025 are about the first ACP.

Further reading

Sources

Frequently asked questions

What is the difference between MCP and A2A?

MCP connects an agent to tools and data: the agent is the client, and an MCP server exposes functions, resources and prompt templates. A2A connects two independent agents: one agent reads another agent's Agent Card, delegates a task to it and tracks the task's status. The A2A docs sum it up as 'MCP is vertical, A2A is horizontal'; they are complementary, not competitors.

What is an Agent Card in A2A?

An Agent Card is a JSON document describing an A2A agent: who it is, at which URL and over which protocol binding (JSON-RPC, gRPC, HTTP+JSON) it can be reached, which skills it offers and which authentication schemes it requires. Per the spec it is typically published at https://domain/.well-known/agent-card.json and can optionally be signed with JWS.

Is AP2 an extension of A2A, MCP or UCP?

AP2's own docs are not consistent on this: the home page introduces AP2 as an extension for A2A and UCP, the principles section of the same page says 'an open extension for A2A and MCP', and the overview document lists all three: A2A, MCP and UCP. The safe reading: AP2 is the layer that carries payment authorization; its integrations with A2A and UCP are documented, and MCP is among the intended carriers.

What is x402, and does it require crypto?

x402 is an open payment protocol that revives HTTP's 402 Payment Required status code. The server returns 402 with payment requirements, the client retries with a signed payment payload, and a facilitator verifies and settles the payment. The spec aims to be network- and currency-agnostic and says it covers fiat too, but today's SDKs and schemes are mostly for blockchain networks and stablecoins.

Do OpenAI's ACP and Google's UCP do the same thing?

Largely the same layer: both standardize how an AI surface talks to a merchant about products, carts and checkout, and both keep the merchant as the merchant of record. ACP is maintained by OpenAI and Stripe and is used on the ChatGPT side; UCP was developed by Google with Shopify, Etsy, Wayfair, Target and Walmart and is used on Google's AI Mode and Gemini surfaces. You implement the protocol of the surface you want to sell on.

What does Visa's Trusted Agent Protocol do?

It lets a merchant verify that an agent visiting its site is registered and authorized to act for a user. The agent signs every request with HTTP Message Signatures (RFC 9421); the signature carries timestamps, a single-use nonce, a key ID and a tag saying whether the agent is browsing or paying. It solves agent identity and intent, not the payment itself.

Do I need all of these for a simple agent?

No. If your agent only uses its own tools, MCP (or the model's native function calling) is enough. Add A2A when you delegate work to another team's or company's agent. Payment protocols only come into play when the agent actually spends money, or when you sell to agents.