The Agentic Protocols That Will Define the Next Decade of Software
What every AI engineer needs to know about MCP, A2A, ANP, and Agora
Last week, I watched a demo that broke my brain.
An AI agent was planning a conference trip. Nothing special at first glance. We've all seen ChatGPT write itineraries. But this agent actually booked the flight. Then it found a hotel within walking distance from the venue. Then it checked my calendar and registered me for sessions when I was free. Then it expense-reported the whole thing.
It used seven different AI services from different companies, and they all just... worked together. No custom integrations. No API wrapper complexity. No six-month enterprise deployment cycle.
That demo used three different agent protocols that didn't exist a year ago. And if you're building anything with AI right now, you need to understand why these protocols are about to transform everything.
I went deep into the research to figure out how this was possible and found a comprehensive academic survey that maps out the entire landscape of AI agent protocols. What follows is my distillation of that research, rewritten into something useful for those of us actively building with AI today.
The Integration Challenge Nobody Talks About
Here's the reality of building with AI agents: we have incredible capabilities locked behind painful integration efforts.
ChatGPT can write code. Claude can analyse documents. Other agents handle tasks like SQL queries or video editing. Each one is powerful on its own. But getting them to work together is where it all starts to break.
I spent three months on what seemed like a simple project : An AI system to monitor pull requests, run tests, and updates the project board. I used three AI services, each doing a different part. The integration turned out to be harder than the actual logic. When OpenAI changed their function-calling format, I had to scramble. When the project management tool updated their webhook format, more late-night fixes followed.
This isn't a failure of agents. It's the growing pain of a new ecosystem. Everyone is solving the same integration problems in slightly different ways. Wheels are being reinvented constantly.
It's exactly where the early web was before we had standards. The answer isn't to complain about the chaos. It's to build the bridges that connect these systems.
The WordPress Moment
Remember WordPress? Before it took over the web, every CMS had a unique plugin system. To install a contact form on Drupal, you had to learn its specific architecture. The same form on Joomla required completely different code.
Then WordPress introduced a common plugin architecture. One contact form plugin could work across millions of sites. Developers could build once and deploy everywhere. The ecosystem exploded.
AI agents are going through a similar shift. But instead of contact forms, the focus is on how agents discover each other, share capabilities, and work together on complex tasks.
Making Sense of the Protocol Zoo
The academic survey I found creates a taxonomy that explains why we have different protocols instead of one protocol to rule them all. Once you understand this framework, choosing the right protocol becomes obvious.
Protocols fall into two main categories based on what problem they're solving:
Context-Oriented Protocols: These help agents interact with their environment: tools, APIs, databases. Think of them as the "hands" of an agent, letting it touch and manipulate the world. MCP lives here.
Inter-Agent Protocols: These help agents work with other agents. They're about coordination, communication, and collaboration. This is where A2A, ANP, and Agora live, each solving different aspects of agent teamwork.
The survey further breaks down Inter-Agent protocols by the type of collaboration:
General-Purpose: Protocols like ANP and A2A that work for any kind of agent interaction
Domain-Specific: Specialized protocols for specific scenarios:
Human-Computer: How agents interact with humans (think chatbots, but smarter)
Robot-Agent: Physical robots coordinating with AI agents
System-Agent: Infrastructure-level coordination between AI systems
This taxonomy isn't just academic navel-gazing. It explains why your agent integration is such a mess right now. You're probably trying to use a context-oriented solution (like function calling) for an inter-agent problem (like coordinating multiple AIs). Or you're using a general-purpose protocol when you need domain-specific features.
Understanding this taxonomy is like having a map. When you need an agent to query your database? Context-oriented protocol. When you need three agents to collaborate on a task? Inter-agent protocol. When you need your warehouse robots to coordinate with your inventory AI? Domain-specific robot-agent protocol.
Now let's dive into how each protocol fits into this framework and why that matters for your code...
MCP: The "Let Me Use Tools" Protocol
Anthropic's Model Context Protocol (MCP) is simple. It standardises how agents access external tools and data. That's it. But that simplicity is the point.
Consider a typical setup: your AI needs to check Stripe, post to Slack, and update GitHub. You now deal with three different authentication flows, three API styles, and three ways of handling failure. If any of them changes, your code breaks.
MCP proposes a different model: what if every tool followed the same interface?
Imagine all tools exposing themselves like standard sockets. The AI doesn't care whether it's talking to Stripe or Slack. It knows how to plug in. When Stripe updates their API, they just update their MCP adapter. You don't change anything.
What's clever is how MCP separates "thinking" from "doing." Instead of the AI generating an API call with your credentials and sending it to a remote server, it says, "I need customer data for john@example.com." Your local client fetches that data using your secure credentials, which never leave your machine.
This is not theoretical. It's the kind of architectural safety that actually makes production deployments viable.
Note: incorrect implementation of MCP can lead to a lethal trifecta of capabilities that can let an attacker steal your data
A2A: When Agents Collaborate
Google's Agent-to-Agent protocol (A2A) takes a different approach. While MCP is about agents using tools, A2A is about agents working with each other. Not forwarding messages, but true collaboration.
The research shows that multi-agent systems need more than messaging. They require shared understanding of goals, long-running task management, and mechanisms for handling failures.
Say you're building an AI system for logistics. The routing agent finds optimal paths. The weather agent flags storm risks. The traffic agent forecasts congestion. The customer communication agent sends updates.
Without A2A, you end up building a distributed system by hand. With A2A, agents advertise their capabilities, track dependencies, and collaborate automatically. If the weather agent detects a storm, dependent agents get notified immediately. If route optimisation fails, other processes pause automatically.
A2A handles the hard parts of distributed orchestration:
Tasks that last hours, not milliseconds
Failures that cascade through dependent agents
Streaming updates in real time
Graph-like dependencies
This orchestration logic is difficult to implement yourself. A2A gives it out of the box.
ANP: Building an Internet of Agents
The Agent Network Protocol (ANP) is the most ambitious protocol of the lot. MCP focuses on tools, A2A on collaboration, but ANP wants to build an open network where any agent can discover and interact with any other.
It mirrors how the internet works:
Identity layer: Agents get cryptographic IDs carrying trust and capabilities
Protocol negotiation layer: Agents negotiate how to talk. For example, a code analysis agent may use structured ASTs, while a creative writing agent may prefer natural language
Application layer: Standard patterns like service discovery and error handling
The idea is powerful. Imagine a LexisNexis legal agent, a DocuSign contract analysis agent, and a Moody's risk agent spontaneously coordinating across organisational boundaries. ANP wants to make that possible.
Agora: The Protocol That Creates Protocols
Agora takes it further. It's a meta-protocol. It doesn't define interactions. It helps agents create protocols dynamically when existing ones don't work.
Here's a real example: a security agent wants to collaborate with a code analysis agent. But they don't share a common schema. One thinks in attack surfaces, the other in data flows.
Agora enables them to agree on shared semantics on the fly. The security agent might say, "When I mention tainted input, trace it to any external calls." The code agent replies with flow paths. They co-create a protocol, use it, then discard it.
This approach is still experimental, but the research shows it's already viable in limited settings.
Seeing Protocols in Action: A Trip Planning Comparison
To understand how these protocols differ in practice, let's look at how each would handle the same task: planning a five-day trip from Beijing to New York. The architectural differences reveal when you'd choose each approach.
MCP: Centralized Control
In the MCP approach, a single Travel Agent coordinates everything:
Directly calls flight server, hotel server, and weather server
All external services are treated as tools that provide information
Information flows in a star pattern with the agent at the center
The central agent aggregates all responses and generates the complete plan
Best for: Simple workflows where you want tight control and clear accountability. Perfect when you have well-defined tool interfaces and don't need complex inter-service coordination.
Trade-offs: The central agent must know about all services upfront. Adding new services requires updating the central coordinator. Can become a performance bottleneck.
A2A: Distributed Collaboration
A2A organizes agents into logical departments (Transportation, Accommodation & Activities):
Flight Agent and Activity Agent depend on Weather Agent for environmental data
Agents communicate directly without central mediation for every interaction
A Travel Planner coordinates overall results but doesn't micromanage
Each agent handles its specialized domain autonomously
Best for: Complex enterprise scenarios where you want specialized agents that can adapt and coordinate dynamically. Ideal when you need fault tolerance and flexible communication patterns.
Trade-offs: More complex to set up initially. Requires careful design of agent responsibilities and communication patterns.
ANP: Cross-Domain Networks
ANP enables negotiations between agents across organizational boundaries:
Clear separation between Airline Company, Hotel, and Weather Website domains
Cross-domain collaboration through formal protocol-based requests
Agents can discover and interact across security boundaries
Structured handshakes and authentication for each interaction
Best for: When agents need to work across organizational boundaries or when you're building public agent networks. Essential for scenarios involving multiple vendors or security domains.
Trade-offs: Higher overhead for simple tasks. Requires more sophisticated identity and trust management.
Agora: Natural Language Flexibility
Agora converts natural language requests into appropriate protocols:
Parses user intent (origin, destination, duration, budget) from natural language
Generates specialized protocols for different service types
Distributes protocols to appropriate agents (Flight, Hotel, Weather, Budget)
Each agent responds to structured protocols rather than free-form requests
Best for: User-facing systems where flexibility and natural interaction are critical. Excellent when you need to adapt to varied or unexpected requests.
Trade-offs: More complex natural language processing. Potential for misinterpretation of user intent.
Key Architectural Insights
The comparison reveals fundamental design choices:
Control vs. Flexibility: MCP offers maximum control but minimum flexibility. Agora offers maximum flexibility but less predictable control.
Coupling vs. Coordination: MCP creates tight coupling through central coordination. ANP enables loose coupling through standardized protocols.
Simplicity vs. Capability: Simple tasks favor MCP's straightforward approach. Complex multi-domain tasks benefit from A2A's sophisticated coordination.
Internal vs. External: A2A excels within organization boundaries. ANP shines across organizational boundaries.
Understanding these trade-offs helps you choose the right protocol for your specific use case rather than trying to force one approach to fit all scenarios.
What's Working in Production?
Here's a realistic summary of where each protocol stands:
MCP: Production-ready. Anthropic uses it internally. Tools ecosystem is growing. Currently Claude-focused, but expanding.
A2A: Solid engineering. Built for complex workflows at Google scale. May be too heavy for smaller teams.
ANP: Visionary, but early. Needs a critical mass of agents to be useful.
Agora: Research stage. Protocol negotiation works in lab conditions, but not yet robust in the wild.
What This Means for Developers
If you're building AI systems, here's how to act on this today:
Use MCP to integrate tools
Start exposing your tools through MCP adapters. Saves time and makes future upgrades easier.
Design for protocol flexibility
Don't tie your agents to a single protocol. Build in abstraction layers.
Shift from APIs to capabilities
Instead of calling specific APIs, think in terms of what capability you need. This prepares you for protocol-agnostic development.
Get ready for interoperability
Invest now in tooling and design patterns that allow your agents to work across multiple protocols.
Why This Matters Now
Some developers may wait for standards to stabilise. But that's a risky strategy. You'll fall behind the teams already building interoperable systems.
Here's why this is urgent:
Integration is the bottleneck: AI projects fail not because the models are bad, but because connecting systems is painful
Ecosystem lock-in is coming: Early adopters of protocols will define the dominant ecosystems
VCs are watching: If you're building infra or tools, protocol support is now expected
Complexity is growing fast: Future systems will involve dozens or hundreds of agents. Without standard coordination, they'll break down
The Bigger Shift
This is part of a long-term trend:
Isolated computers became the internet
Static websites became APIs
Monoliths became microservices
Now, LLMs are becoming networks of autonomous agents
Each shift required new protocols. This one is no different. The value is moving from isolated brilliance to connected intelligence.
What's Next
Based on trends from both research and industry:
6 months: MCP becomes the tool integration default
12 months: A2A-style orchestration becomes essential in enterprise environments
24 months: First large-scale networks of agents using ANP emerge
5 years: Agora-like systems allow agents to create bespoke protocols automatically
This is the start of a new layer in the internet stack. One not built for humans, but for agents. They will find each other, negotiate, collaborate, and act at machine scale.
These protocols aren't perfect. But they are necessary. And if you want to be part of this future, the time to start building is now.