A few weeks ago I wrote about replacing MCPs with skills and scripts. Someone pushed back in the comments over on LinkedIn with one exception: agent to agent communication. I pointed them at Agent Communication Protocol or using markdown files because I didn’t think MCP was the right answer, but the question stuck, and I’ve spent some time since looking at A2A properly.
In the skills post I argued that for most tool connections, a skill file plus a script beats an MCP server. It’s less context, and therefore fewer tokens. I still think that’s true for access to systems like Jira.
My answer for agent coordination was “just use markdown files.” One process writes to a known location, the next one picks it up. But that’s not really agent to agent communication, is it? That’s more of an agentic workflow.
Why MCP is the wrong layer
MCP was never designed for agents talking to each other. Stretch it into that role and you lose the things you want when agents coordinate: lifecycle management, discovery, async streaming, the ability to pause mid-task and ask for input. MCP gives you none of that. You’d be rebuilding it yourself on top of a tool connection protocol.
Using MCP for agent to agent communication is reaching for the wrong layer.
What A2A is
ACP, the Agent Communication Protocol, was IBM’s open standard for agent to agent comms. It’s now merged into Google’s Agent2Agent protocol, A2A, under the Linux Foundation. Same concepts and REST API, one standard instead of two competing ones.
What surprised me looking at the samples repo is how concrete it is. Each agent runs as its own standalone server on its own port, framework-agnostic. There are samples for Google ADK, LangGraph, CrewAI, LlamaIndex, Semantic Kernel, Marvin, AG2. The same agent can be called from any client that speaks A2A, regardless of what framework it was built with.
a2aproject/a2a-samplesI’d been thinking about agent coordination as something you orchestrate yourself, either manually or with a separate layer you control. A2A is built for a different shape: an agent you call and trigger automatically. It lives somewhere else, and another system discovers and talks to it over a standard interface. It’s a remote procedure call with lifecycle and state, and it streams as the agent works. You’re not leaving a file for another process to pick up.
When markdown still wins
My markdown handoff pattern is still the right answer for the simple case: two agents, one hop, you control both ends. The moment you have multiple agents, or agents you don’t control, or long-running tasks that need to pause and resume, you want a real protocol. A2A looks like the one the industry is settling on.
I haven’t built anything with A2A yet, just read through the docs and poked around the samples repo. That’s not enough to tell you how it holds up in production.
Where I’m at with A2A
I don’t know yet whether A2A is the protocol that wins. But it’s the one I’d be looking at seriously if I were building multi-agent systems today, which, given where the comment thread went, I might be soon.