MCP vs A2A: which one do you actually need?
Both let agentic systems reach further than themselves. Only one of them is worth your attention today.
The idea to hold onto
MCP is agent to service. A2A is agent to agent.
That's the whole distinction, and everything below is just what falls out of it.
An MCP server standardises how an agent talks to an external system: content marketing, project tickets, whatever the service does. However different the underlying service is, the shape of the call never changes. A2A does something different: it lets one agent call another agent directly, and that second agent might do absolutely anything on the way to a result, including calling MCP itself.
What MCP already does for me
MCP is a standardised way for agentic systems, the LLMs, the agents themselves, to talk to external services. My own Inkie platform has an MCP server for content marketing: scheduling, uploading images, creating and generating content, all callable the same way regardless of what's happening underneath. Linear, the project management tool my agents use, has one too: my agents move tickets, set things to done, all programmatically, without me hand-holding any of it.
Loads of systems support MCP already. My agentic systems call into it constantly, and so does my dev team's tooling. It's the protocol doing the real work right now.
What A2A adds
A2A stands for agent to agent communication. Google invented it, early 2025. On the surface it sounds similar to MCP, but the shape is different: instead of an agent calling an external system (Linear, in the MCP example above), A2A lets one agent call another agent directly.
So your agent, working inside one system, calls out to another agent to get something done. That second agent might then call a third agent, or fall back to MCP, hit a database, or use its own tools, before it hands anything back to you. Same broad goal as MCP, agents reaching further than themselves, but a genuinely different protocol underneath.
Why I'm not rushing to learn it
I don't run an A2A server, and I've never actually called into one, so I can't tell you first-hand how widely it's used day to day. What I do know is that the big spec-backing players (IBM among them) are behind it, because they're literally maintaining the spec.
That's a real signal, just not the same as adoption in the wild.
And MCP is, by a wide margin, more widely supported right now.
Do you actually need it
If you're building agentic systems, MCP is the one to know. A2A is worth a look, but:
Don't make a fuss learning it in depth unless you genuinely need to.
That need is narrow: someone calling into you requires it, or the only system you can reach speaks it.
A few common questions
What's the one-line difference between MCP and A2A? MCP is agent to service, your agent calling out to something like Linear or a CMS. A2A is agent to agent: one agent calling another directly, and that agent might do anything on its way to an answer, including calling MCP itself.
Who built A2A, and when? Google, early 2025. IBM and other heavyweight names have since signed on as spec-backers.
Do you run an A2A server yourself? No, not yet, and I haven't called into one either. So treat what I say about adoption here as an outsider's view, not a war story.
Can MCP and A2A work together? Yes, and that's the interesting bit. An agent you reach over A2A can fall back to MCP, hit a database, or use its own tools before it answers you, so the two aren't really rivals, they can sit in the same call chain.
Is A2A worth learning right now? Only if you need it: someone calling into you requires it, or the one system you can reach only speaks A2A. Otherwise, MCP is where the real, working adoption is today.
Have a look at it and let me know what you think. Go out and make some cool shit.
