Why Six Protocols in 18 Months?
In late 2024, Anthropic shipped MCP and solved one specific problem: getting AI models to reliably talk to external tools. It worked. Within weeks, every major AI system was adding MCP support, and thousands of MCP servers appeared on GitHub.
But MCP only solved the vertical problem — one AI model connecting to one set of tools. The moment people started building multi-agent systems (one AI orchestrating other AIs), a new set of problems appeared: How do agents find each other? How do they delegate tasks? How do you add governance and access control when an agent is talking to 50 other agents across 10 different organizations?
That's why the other five protocols exist. Each one solves a different layer of the same underlying problem: how do you build reliable, trustworthy, interoperable AI agent systems at scale?
The Six Protocols
Connects AI models to external tools, databases, files, and APIs via a standard client-server interface.
Lets AI agents from different vendors discover each other and collaborate on tasks — peer-to-peer.
Adds policy-based routing and governance on top of A2A — the BGP of multi-agent enterprise systems.
DNS-like discovery layer for agents across organizations — 75+ companies building toward an "Internet of Agents."
Agent communication for environments without internet access — hospitals, defense, on-premise enterprise.
Standardizes how AI agents integrate with code editors — lets Claude Code and Gemini CLI run interchangeably in any IDE.
MCP: The One You Probably Already Use
MCP is the most mature and widely adopted of the six protocols. Anthropic shipped it in November 2024 and within three months it became the default standard for AI tool integration. Claude, Cursor, VS Code Copilot, Windsurf, and dozens of other AI tools all speak MCP natively.
The architecture is a clean client-server model built on JSON-RPC 2.0. The MCP client (your AI tool) connects to MCP servers (the integration layer), and the servers expose tools, resources, and prompts. Local servers communicate over stdio. Remote servers use HTTP with Server-Sent Events.
When to use MCP:
- Your AI needs to read/write files, query databases, call APIs, or access internal tools
- You want a single integration point that works across Claude, Cursor, VS Code, and every other MCP-compatible client
- You're building a product that external developers will integrate with
MCPHubz indexes over 2,000 MCP servers across every category. Browse the directory →
A2A: Agent-to-Agent, Google's Answer to the Orchestration Problem
Google shipped Agent2Agent in April 2025 and donated it to the Linux Foundation two months later — a signal that they're serious about making it a neutral open standard rather than a Google-owned protocol. Over 50 technology partners helped build it, including ServiceNow, SAP, and Salesforce.
The core innovation is the Agent Card — a JSON manifest published at /.well-known/agent-card.json. Any A2A-compatible agent can discover another agent's capabilities by fetching its Agent Card, then delegate tasks to it using JSON-RPC over HTTP.
Real-world A2A in action:
Tyson Foods and Gordon Food Service use A2A to automate supply chain coordination across vendor boundaries. A procurement agent at Tyson can discover and delegate to a fulfillment agent at a supplier — without a custom API integration between the two systems.
When to use A2A:
- You're building multi-agent systems where one AI orchestrates others
- You need agents from different vendors or organizations to collaborate
- Your use case involves task delegation, parallel processing, or agent specialization
Important distinction: A2A and MCP are not competitors. MCP handles the vertical connection (agent to tools/data). A2A handles the horizontal connection (agent to agent). Most production multi-agent systems will use both.
AGP: When A2A Gets Enterprise-Scale
Agent Gateway Protocol is Google's extension to A2A — designed specifically for organizations that need governance, access control, and policy enforcement across hundreds of agents. The analogy the designers use is BGP (Border Gateway Protocol), the protocol that routes traffic across the internet. AGP does for agents what BGP does for packets.
AGP organizes agents into domain-specific squads that mirror enterprise org structures — finance agents, HR agents, operations agents. When a request comes in (say, "run quarterly financial analysis"), AGP routes it to the right squad based on policy rules, not hard-coded logic.
Who this is for:
Large enterprises deploying AI across multiple departments and needing audit trails, compliance controls, and centralized governance. If you're a startup or mid-size company, A2A alone is sufficient — AGP is for the Fortune 500.
AGNTCY: The Internet of Agents
Cisco's Outshift lab shipped AGNTCY in March 2025 with a bold vision: build the discovery layer for AI agents the same way DNS built the discovery layer for websites. Instead of hard-coding which agents a system can talk to, AGNTCY provides a distributed hash table-based directory where agents can find each other dynamically.
Think about what DNS did for the web: it made the internet navigable without everyone memorizing IP addresses. AGNTCY is attempting the same abstraction for agent networks — a universal phonebook where any agent can look up any other agent by capability, not by hard-coded endpoint.
The honest assessment:
AGNTCY is the most ambitious of the six protocols and also the least mature. The vision of a truly decentralized "Internet of Agents" is compelling, but getting 75+ companies to agree on a shared discovery standard is orders of magnitude harder than shipping a client-server protocol. Watch this space — but don't build production systems on AGNTCY today.
IBM ACP: When the Cloud Isn't an Option
IBM's Agent Communication Protocol solves a problem that most protocol designers ignored: what happens when your agents can't access the internet? Hospitals processing patient data under HIPAA, defense contractors operating in classified environments, industrial facilities with air-gapped networks — these environments need AI agent communication but can't send data to external cloud services.
ACP is designed local-first. It uses HTTP with SSE streaming and stores agent metadata in code decorators rather than remote registries. It is deliberately web-agnostic — it doesn't assume your network has internet access.
Who this is for:
Healthcare, defense, financial services with strict data residency requirements, and any enterprise that operates on-premise infrastructure. If your data cannot leave your network, IBM ACP is currently the only protocol designed around that constraint.
Zed ACP: Fixing the IDE Fragmentation Problem
Every major code editor has its own way of integrating AI agents. VS Code does it one way, JetBrains another, Cursor another, Neovim another. Zed's Agent Client Protocol is an attempt to standardize that interface so that Claude Code, Gemini CLI, and any other AI coding agent can run inside any editor without custom integrations.
It uses JSON-RPC over stdio streams — deliberately similar to MCP's local transport — and separates agent logic from UI implementation. The result: an agent built for Zed ACP works in JetBrains, Neovim, and Emacs without modification. SDKs are available in TypeScript, Python, Rust, and Kotlin.
Adoption so far:
JetBrains has committed to full IDE ecosystem support. Neovim and Emacs implementations exist. The protocol is early but gaining traction specifically because developers are tired of AI tools being IDE-locked.
Side-by-Side Comparison
Which Protocols Does Your Stack Actually Need?
Solo developer / small team
MCP only. It solves the problem you actually have right now — connecting your AI coding tools to your databases, APIs, and files. Everything else is premature.
Building a multi-agent product
MCP + A2A. Use MCP for your agents to access tools and data. Use A2A to let those agents communicate and delegate tasks to each other. These two protocols are complementary and both have mature implementations.
Enterprise AI platform
MCP + A2A + AGP. Add AGP when you need policy-based routing, access controls, and audit trails across a large fleet of agents. Watch AGNTCY for cross-organizational use cases but don't build on it yet.
Healthcare / defense / restricted environments
IBM ACP as primary. MCP for internal tool integration where connectivity exists. The defining constraint is data residency — IBM ACP is designed from the ground up for environments where data cannot leave the network.
Building an AI coding tool
MCP + Zed ACP. MCP for tool access. Zed ACP if you want your agent to work across all major editors without building separate integrations for each.
The Bigger Picture
Six protocols in 18 months sounds like fragmentation. It isn't. It's layer formation — the same process that gave us TCP/IP, HTTP, DNS, and TLS. Each of those protocols solves a specific layer of the networking stack and they all work together. The AI agent stack is forming the same way.
MCP is already the TCP/IP of AI tools — foundational, widely adopted, not going anywhere. A2A is establishing itself as the HTTP layer for agent-to-agent communication. AGP and AGNTCY are addressing the routing and discovery layers. IBM ACP handles the edge case that the internet-first protocols ignore.
The protocols that will dominate are the ones backed by open governance bodies — MCP (Anthropic, broadly adopted), A2A (Linux Foundation), AGNTCY (Linux Foundation). Protocols owned by single vendors tend to get marginalized over time unless those vendors are dominant enough to force adoption. Watch the Linux Foundation stewardship of A2A and AGNTCY closely — the transition from "Google's protocol" to "the Linux Foundation's protocol" was a deliberate move to accelerate adoption.
Find the Right MCP Server for Your Stack
MCPHubz indexes 2,000+ MCP servers across every category — databases, APIs, communication tools, cloud providers, and more. All health-scored and curated.