The USB-C Moment for AI: MCP vs A2A vs ACP, and How Agents Talk to Each Other
Part 8 of AI From Zero to Agents. The standards that let AI plug into tools and into other AI: MCP (agent to tools), A2A (agent to agent) and the three different things people call “ACP”, with pictures, a side-by-side comparison and a timeline.
Series · AI From Zero to AgentsPart 8 of 9
- 1 AI for Newbies: The 10-Minute Guide That Finally Makes It Click
- 2 ChatGPT Isn't Magic, It's Autocomplete on Steroids
- 3 Not All AI Is the Same Brain: Meet the Model Family
- 4 ChatGPT vs Claude vs Gemini vs Grok vs Llama vs Perplexity: Which AI Should You Actually Use?
- 5 Free, Open and on Your Laptop: Open-Source Models and the Secret Currency Called Tokens
- 6 From Chatbot to Coworker: What Agentic AI Is and How to Build Your First Agent
- 7 Stop Prompting, Start Automating: AI Workflows That Save You Hours Every Week
- 8 The USB-C Moment for AI: MCP vs A2A vs ACP, and How Agents Talk to Each Other
- 9 Let's Build It: A Hands-On Agent-to-Agent Walkthrough

Most of us still have the drawer. A charger for the phone, a different one for the tablet, another for the laptop, and somewhere at the back a cable that fits nothing you currently own. Then USB-C came along and one cable started fitting almost everything.
AI ran into the same mess in 2024, and over 2025 and 2026 it got its own USB-C moment. This part is about the three acronyms you'll hear in pretty much every AI meeting now: MCP, A2A and ACP. There's a twist with that last one, because "ACP" turns out to mean three different things.
In Part 6 we gave agents tools, and in Part 7 we wired them into workflows. Both leave the same question hanging: how do all these pieces actually plug into each other?
The integration spaghetti
Before there were standards, every AI app needed its own custom connector for every tool. Five AI apps and twenty tools meant a hundred separate integrations, each one built and maintained by somebody.

A shared protocol turns that multiplication into addition. Each app learns the standard once, each tool speaks it once, and everything works with everything else. That's exactly the trick USB-C pulled on our chargers.
Who talks to whom

MCP: how an agent reaches its tools
The Model Context Protocol is a standard way for an AI application to connect to tools and data: your files, calendar, CRM, databases, GitHub, Slack and so on.
Anthropic open-sourced it in November 2024, and during 2025 OpenAI, Google, Microsoft and plenty of others adopted it. In December 2025 Anthropic handed it over to the newly formed Agentic AI Foundation under the Linux Foundation, which means no single company controls it any more. For a standard that everyone is supposed to build on, that matters a lot.

The moving parts are simpler than the name suggests. The AI app you're using (a chat assistant, a code editor, an agent) is the host. Each system you want to connect gets a small adapter called an MCP server, and that server offers the AI three kinds of thing: tools it can call ("create ticket", "query sales"), resources it can read ("this file", "that table") and ready-made prompts. You write the MCP server for your system once, and every MCP-compatible app can use it from then on.
The current specification is version 2026-07-28. It now has extensions for long-running tasks and for MCP Apps, which render interactive charts and forms right inside the conversation.

What does that look like day to day? You ask your assistant "What did the Acme team say about pricing last month, and is their renewal in the CRM yet?" Behind the scenes it goes through your email connector and your CRM connector and answers with both. You never think about MCP at all, which is rather the point.
A2A: how agents work with each other
Agent2Agent is a standard for independent AI agents to find each other, hand off tasks and send results back, even when they were built by different companies on different platforms.
Google announced it in April 2025 with more than 50 partners. It moved to the Linux Foundation in June 2025, reached version 1.0 in 2026, and in August 2026 joined MCP under the same Agentic AI Foundation. So the two protocols most people care about now live under one roof.

It works in four steps. Every A2A agent publishes an Agent Card, a sort of public business card at a standard web address, saying who it is, what it can do and how to reach it. Another agent reads that card and sends a message asking for some work. The work becomes a task with a status (submitted, working, input-required when it needs something from you, completed, failed and a few others). When it's done, the results come back as artifacts, which can be text, files or structured data.
The part I like most is that agents don't have to reveal how they work inside. A bank's credit-check agent can serve a partner's loan-application agent without exposing its models, its data or its prompts. That opacity is deliberate, and I think it's how companies will actually let their agents cooperate: nobody has to hand over the family silver to take part.

So are MCP and A2A competitors?
No, and this is the confusion I get asked about most. The shortest version I've found: MCP is how an agent uses its tools, and A2A is how an agent works with colleagues.
Picture a travel agency. The travel agent uses a booking system, a currency converter and a calendar, and those are tools, so that's MCP. When the trip needs a visa, the travel agent passes the job to a visa specialist at another firm, who has their own tools. That handover is A2A. Most serious agent systems end up using both, with A2A between the agents and MCP inside each one.
And then there's ACP. Three of them.
This one catches out even technical people. In 2025, three unrelated projects all settled on the initials ACP.

The first is IBM's Agent Communication Protocol, from the BeeAI project. It launched in March 2025 as an agent-to-agent protocol with a simpler, REST-style design. In August 2025 it merged into A2A under the Linux Foundation, and its team now works on A2A. If someone asks you "ACP or A2A?", this is usually the ACP they mean, and the contest is over because the two joined forces.
The second is Zed's Agent Client Protocol, launched in August 2025. It connects code editors to coding agents, much as the Language Server Protocol connects editors to programming languages. Any agent that speaks it (Claude Code, Codex, Gemini CLI and others) can plug into any editor that supports it, such as Zed or JetBrains.
The third is the Agentic Commerce Protocol from OpenAI and Stripe, launched in September 2025 so AI agents can buy things from merchants safely. It's what sits behind checkout inside ChatGPT. Google has a related standard for agent payments called AP2.

Side by side
| MCP | A2A | ACP (IBM) | ACP (Zed) | ACP (Commerce) | |
|---|---|---|---|---|---|
| Connects | Agent ↔ tools & data | Agent ↔ agent | Agent ↔ agent | Editor ↔ coding agent | Agent ↔ merchant |
| Started by | Anthropic | IBM | Zed | OpenAI + Stripe | |
| Launched | Nov 2024 | Apr 2025 | Mar 2025 | Aug 2025 | Sep 2025 |
| Status (Oct 2026) | Spec 2026-07-28, Agentic AI Foundation | v1.0, Agentic AI Foundation | Merged into A2A (Aug 2025) | Active, open standard | Active, open standard |
| Analogy | USB-C port | Phone call between firms | (now part of A2A) | Universal adapter for editors | Checkout counter |
| You'll meet it when | Connecting AI to your company systems | Agents from different vendors cooperate | Reading older articles | Choosing AI coding tools | Agents shop for you |
How we got here

What strikes me about this timeline is the speed, and how much the competitors cooperated. Rival companies handed their protocols to a neutral foundation within months of launching them. That almost never happens in our industry, and it tells you how seriously everyone takes agents as the next platform.
What I'd do with this
If you're buying AI tools, ask the vendor whether they support MCP and A2A. It's the 2026 version of checking a device has USB-C, and standards are your best protection against lock-in. If you own a system or a pile of data, an MCP server for it makes it usable by every assistant your company adopts from now on.
If you're thinking about agent strategy, I'd design agents as specialists with clear skills, published through A2A Agent Cards, rather than one giant agent that tries to do everything. And please don't forget that a protocol is a doorway. Connect only MCP servers you trust, give each one the smallest permissions that work, and require approval for anything with consequences. The MCP specification itself says hosts must get the user's consent before invoking tools.
A quick glossary
- Protocol: an agreed set of rules for how two systems talk to each other.
- MCP server: an adapter that exposes a system's tools and data to AI apps.
- Agent Card: an A2A agent's public description of who it is, what it can do and where to reach it.
- Task and artifact: in A2A, a piece of delegated work and its result.
- Agentic AI Foundation (AAIF): the Linux Foundation body that now looks after both MCP and A2A.
Ten minutes to see it for yourself
Open the settings in your AI assistant and look for something called Connectors, Integrations, Apps or Extensions. Many of the connectors you'll find there (Google Drive, GitHub, Notion, Slack) are MCP under the hood. Connect one you use every day, read-only, and ask it a question that needs that data. Congratulations, you've just used the USB-C of AI.
In the final part we stop talking and build something: a few small agents that find each other through Agent Cards and work together over A2A, with the real messages they send.
More notes

AI Agents Are the New Shadow IT—and Permission Is the Real Problem
Why autonomous AI deployments should be governed by permissions and transactions, not clever prompts.

Why a 100% SLA isn't feasible in technology
A customer asked me why the cloud provider doesn't just replicate everything to another region and promise 100% uptime. The honest answer has more to do with physics, change and regulators than with greed.

Hotels Need an Event Backbone, Not Another Dashboard
A vendor-neutral hospitality integration pattern using OCI APIs, streaming and operational data governance.