The Problem You Probably Have Already
If you're building agentic systems in 2025, chances are you've already got two integration layers in your stack:
- MCP (Model Context Protocol) — wiring your AI models to databases, APIs, filesystems, internal tools
- A2A (Agent-to-Agent) protocols — letting your agents discover, negotiate with, and invoke each other
They're not competing. They're complementary. But without a clear interoperability story, you're setting yourself up for the kind of integration spaghetti that kept enterprise architects busy (and miserable) in the ESB era.
What MCP Actually Does
MCP is Anthropic's answer to a simple problem: how do you give an LLM structured, reliable access to external resources without writing bespoke glue code for every data source?
Instead of hardcoding database queries or API calls into your prompts, you expose them as MCP servers. Your AI client connects via a standard protocol, discovers available tools, and invokes them with typed parameters.
Example use case:
# MCP server exposes a tool
@mcp_tool
def query_customer_orders(customer_id: str) -> list[Order]:
return db.execute("SELECT * FROM orders WHERE customer_id = ?", customer_id)
Your LLM can now call query_customer_orders as a function — no prompt engineering, no brittle scraping, no hoping the model "figures it out".
MCP is vertical integration: connecting one agent to the resources it needs to do its job.
What A2A Actually Does
A2A is horizontal. It's about agents talking to other agents.
Imagine you've got:
- A customer service agent that handles support tickets
- A logistics agent that tracks shipments
- A billing agent that processes refunds
When a customer asks "Where's my refund?", the support agent needs to talk to billing. That's A2A.
A2A protocols define:
- Discovery: how does Agent A find Agent B?
- Capability negotiation: what can Agent B actually do?
- Invocation: how does Agent A call Agent B and handle the response?
Unlike MCP, A2A is still fragmented. There's no single standard. You might be using:
- HTTP APIs with custom service meshes
- Pub/sub queues (Kafka, RabbitMQ)
- gRPC with Protobuf schemas
- Proprietary frameworks from LangChain, AutoGen, CrewAI
Each works. None interoperate cleanly.
Why This Feels Familiar (and Not in a Good Way)
If you worked in enterprise integration in the 2000s, this smells like ESB déjà vu.
The Enterprise Service Bus promised to solve the n-squared integration problem: instead of every system talking directly to every other system, route everything through a central bus.
It worked — until it didn't. ESBs became:
- Single points of failure
- Performance bottlenecks
- Proprietary lock-in traps (looking at you, TIBCO and WebSphere)
The two-layer stack emerging now — MCP below, A2A above — risks the same fate if we're not careful.
What You Should Do About It
1. Treat MCP as infrastructure, not application logic
MCP is brilliant for standardising resource access. Don't abuse it by cramming business logic into MCP tools. Keep them thin, composable, and stateless.
2. Pick one A2A pattern per bounded context
Don't mix pub/sub and RPC in the same workflow unless you have a damn good reason. Consistency beats flexibility when debugging multi-agent failures at 2am.
3. Design for replaceability
Whatever A2A framework you choose today will probably be legacy in 18 months. Wrap it. Abstract it. Make it swappable.
Example:
class AgentInvoker(Protocol):
def invoke(self, agent_id: str, task: dict) -> dict:
...
class KafkaAgentInvoker(AgentInvoker):
# Implementation today
class GrpcAgentInvoker(AgentInvoker):
# Swap in tomorrow
4. Monitor both layers separately
MCP failures look different to A2A failures:
- MCP: "Tool not found", "Database timeout", "API key expired"
- A2A: "Agent unavailable", "Circular dependency", "Message bus backlog"
Your observability stack needs to distinguish them.
The Boring Truth
There's no silver bullet yet. MCP is maturing fast, but A2A is still the Wild West. If you're building production agentic systems — especially in regulated industries or at scale — treat this as an architecture risk, not just a tooling choice.
You don't need to freeze development. But you do need to:
- Isolate the integration layer
- Version your agent contracts
- Plan for migration
The teams that get this right won't be the ones with the cleverest agents. They'll be the ones who can rewire them without a full rewrite.
If you're evaluating MCP, A2A, or any other part of the agentic stack and want a second opinion, teams specialising in AI automation and software development can help you de-risk the architecture before you're too deep to reverse course.
But honestly? Just don't build another ESB. We've been there. It wasn't fun.
