Six months ago, connecting an AI agent to an external tool meant writing custom API glue. Now there are six competing protocols trying to standardize the job, and Google just published a guide sorting out which does what.
The March 18 blog post by Shubham Saboo and Kristopher Overholt on the Google Developers Blog walks through each protocol's scope, how they overlap, and where Google's own Agent Development Kit (ADK) fits in. If you build anything that involves agents calling tools or talking to other agents, this is the clearest map of the landscape I've seen so far.
The Protocol Stack, Plain English
MCP (Model Context Protocol) handles the connection between an agent and the tools or data sources it needs. Instead of writing custom integration code for every API, MCP servers advertise what they can do, and agents discover those capabilities automatically. This is the one most developers will reach for first, and it already has real traction with integrations for databases like PostgreSQL and BigQuery, plus services like Notion and Mailgun.
A2A (Agent2Agent Protocol) solves a different problem: how agents find and talk to each other. Agents publish capability cards at a standard URL (/.well-known/agent-card.json), so a general-purpose agent can route a specialized query to the right remote agent without anyone hardcoding the connection. Think of it as DNS for AI agents.
UCP (Universal Commerce Protocol) and AP2 (Agent Payments Protocol) tackle commerce. UCP standardizes shopping workflows across different merchants regardless of transport layer (whether that is REST, MCP, or A2A). AP2, currently at v0.1, adds authorization guardrails and audit trails on top, with three components: IntentMandate (what the agent is allowed to do), PaymentMandate (signed authorization to spend), and PaymentReceipt (proof it happened).
A2UI and AG-UI both address the interface layer but from different angles. A2UI lets agents dynamically compose user interfaces from 18 component primitives (rows, columns, text fields, buttons, checkboxes, date inputs). AG-UI standardizes the streaming events between an agent backend and a frontend, emitting structured events like RUN_STARTED, TOOL_CALL_START, and TEXT_MESSAGE_CONTENT so you don't write custom event-parsing boilerplate for every project.
What Google Is Actually Saying Here
The practical advice boils down to: start with MCP, add protocols as your use case demands them, and don't try to adopt everything at once. That's sensible. Most agents today just need to call tools reliably. Agent-to-agent communication and commerce protocols matter for larger systems, but they're earlier in maturity.
Google's ADK conveniently supports all six, which is both helpful and strategic. By publishing this guide, Google positions itself as the neutral infrastructure layer across a fragmented space. Each protocol has a different backing organization (MCP from Anthropic, A2A from its own consortium, the commerce protocols from Google's agentic commerce team), but ADK ties them together.
The Fragmentation Problem Nobody Solved Yet
The guide's biggest gap is also the industry's biggest gap: there is no comparative analysis of competing approaches, and no adoption numbers. We know MCP has momentum. A2A is newer. The commerce protocols are very early (AP2 is literally v0.1). But nobody is saying "here's when you'd pick A2A over just exposing an MCP server," or "here's what percentage of agent frameworks support these."
That ambiguity is the real state of things right now. The protocols exist, the specifications are public, and Google's guide is a genuinely useful reference for understanding what each one does. But we're still in the phase where standards are being planted, not harvested. Developers building agents today should understand these protocols, wire up MCP because it's practical right now, and watch the rest closely as real-world usage shakes out which ones stick.