The Agentic Payments Stack Explained: MCP, x402, A2A, Visa TAP, and Where the Control Layer Lives
Last updated: 2026-06-07
The agentic payments stack has three layers. A data plane, where agents discover and call tools (MCP, A2A). A money plane, where payments get structured and settled (x402, AP2). And a control plane (spend limits, approvals, per-agent accountability) that's still largely unowned and unstandardized. That last layer is the one teams hit the wall on in production, and it's exactly where Shatale lives.
Key takeaways
- MCP, A2A, UCP, and ACP are data-plane protocols. They carry intent and invocations, not dollars.
- x402, AP2 (Google), and ACP-with-Stripe move the money, the money plane.
- Visa TAP lets merchants verify that the agent at their checkout is legitimate. Useful, but it's identity plumbing, not a control layer.
- The control plane, scoped cards, real-time policy, approvals, immutable audit, is the piece most teams still stitch together by hand.
- Shatale is built for that layer: above issuing, below orchestration.
Why does everyone keep mixing up these acronyms?
In about eighteen months, Google, Anthropic, OpenAI, Stripe, and Visa each shipped something with "agentic" and "payments" in the same breath. MCP, ACP, AP2, UCP, A2A, x402, TAP, the names blur.
They don't compete. Map each one to a layer and the stack snaps into focus.
Three layers are worth separating:
Data plane, agents discover tools, take instructions, call capabilities. No money moves.
Money plane, payment requests get structured, authorized, settled. Dollars move.
Control plane, policy is set and enforced in real time: which agent can spend, how much, on what, with whose sign-off. Accountability lives here.
Most of the noise comes from comparing protocols that sit on different layers. MCP and x402 aren't rivals. Neither are A2A and AP2.
What does each protocol actually do?
| Protocol | Owner | Layer | What it does |
|---|---|---|---|
| MCP (Model Context Protocol) | Anthropic → Agentic AI Foundation (Linux Foundation, Dec 2025) | Data plane | A standard interface for LLMs to discover and call external tools and APIs |
| A2A (Agent2Agent) | Google → Linux Foundation (Jun 2025) | Data plane | Lets one agent hand a task to another, peer-to-peer orchestration |
| UCP (Universal Commerce Protocol) | Google + Shopify and other retailers (Jan 2026) | Data plane | Standardizes the commerce journey, product discovery, carts, order management, so agents can transact with any merchant |
| ACP (Agentic Commerce Protocol) | OpenAI + Stripe (Sep 2025, Apache 2.0) | Data/money bridge | Standardizes agent checkout with merchants; powers ChatGPT Instant Checkout, with Stripe's Shared Payment Tokens as the payment primitive |
| x402 | Coinbase → x402 Foundation (Linux Foundation, Apr 2026) | Money plane | HTTP-native payments: a 402 Payment Required carries a machine-readable request; the agent pays, gets a receipt, continues |
| AP2 (Agent Payments Protocol) | Google → FIDO Alliance (Apr 2026) | Money plane | Signed Intent, Cart, and Payment mandates (W3C Verifiable Credentials) that prove what an agent was authorized to buy, payment-method-agnostic |
| Visa TAP (Trusted Agent Protocol) | Visa, with Cloudflare (Oct 2025) | Web/checkout layer | Agents cryptographically sign their identity into HTTP headers so merchants can verify a legitimate agent at checkout, no policy, no limits |
If your engineering team is "evaluating MCP versus x402," that's usually the wrong frame. They're complements. You'll likely run both.
What's missing from all of them?
The money-plane protocols, x402, AP2, ACP, answer "how do I request and authorize a payment." None of them answer the question your finance team actually cares about: should this agent make this payment, right now, given its delegation, your policy, and the budget left this month?
That's the control plane. It needs four things:
- Per-agent scoped cards, one virtual card tied to one agent, one task, one budget envelope.
- Real-time policy at the authorization moment, checked when the charge fires, not reconciled at month-end.
- Approval workflows, a human in the loop for high-value or out-of-policy spend.
- Immutable audit, who or what spent what, when, and why.
an agent can send a perfectly valid x402 request (correctly formatted, technically authorized) that still blows your vendor policy or your monthly cap. Without a control plane, you learn about it at month-end. With one, the charge never clears.
How do these layers connect in practice?
Take a travel agent booking a hotel:
- The orchestrator calls the booking tool over MCP, discovers it, invokes it, gets a quote.
- The tool returns a payment request shaped as x402 or AP2.
- Before anything settles, the control plane intercepts: Is this agent cleared to book hotels? Is $340/night inside the per-night limit for this trip? Does the merchant pass policy? Yes → it clears on a scoped card. No → it routes to a human.
- At the merchant's site, Visa TAP lets the checkout verify it's dealing with a legitimate agent, and the card itself is a tokenized credential, so the real number never sits in the agent's memory.
Step 3 is the one most teams are missing today, skipped, or held together with brittle custom logic. For the ground-level version of why agent payments differ from human ones, see What Are AI Agent Payments?.
Where does Shatale fit?
Shatale is the control plane. It sits between your orchestration (MCP, A2A) and your money plane (x402, AP2, or a direct issuer): it issues agent-scoped virtual cards, enforces spend policy in real time at the authorization moment, routes exceptions to human approvers, and writes an immutable record of every decision.
It's protocol-agnostic on purpose. MCP, A2A, or something proprietary, the control layer should behave the same underneath.
Frequently asked questions
What's the difference between MCP and x402? MCP is a data-plane protocol, it lets models discover and call tools, but no money moves through it. x402 is a money-plane protocol, it defines how a machine-readable payment request is structured and answered over HTTP. Different layers, used together, not instead of each other.
Does A2A handle payments? No. Google's Agent-to-Agent protocol handles delegation and orchestration between agents. When money needs to move, a separate money-plane protocol (AP2, x402, or ACP) structures it, and the control layer on top is a further concern again.
What is Visa TAP, and does it enforce spend controls? Visa TAP (Trusted Agent Protocol, launched with Cloudflare in October 2025) lets an agent cryptographically sign its identity into HTTP requests so merchants can verify a legitimate agent at or before checkout. It does not enforce per-agent limits, delegation, or approvals. Those need a separate control layer.
Who owns the control plane for agentic payments? As of mid-2026, no standard governs it. Teams either assemble it by hand, custom logic, limits in a spreadsheet, approvals in a Slack thread, or use a purpose-built layer like Shatale. Standardization here is still early.
Can I use x402 and Shatale together? Yes. x402 shapes the payment request; Shatale decides whether to honor it, issues the card that settles it, logs the outcome, and routes the exceptions. Complementary, not competing.
Next: to go a layer deeper on one protocol, read MCP Moves Data, Not Dollars, what MCP does and doesn't do when people say "MCP payments."