Quick Answer: The AI agent protocol stack is made up of four open standards — MCP, A2A, ACP, and ANP — that define how agents access tools, talk to each other, and operate at internet scale. MCP and A2A are the two in production use today; ACP merged into A2A in 2025; ANP is an emerging experimental layer.
AI agents are moving beyond single-model chat into distributed systems where multiple agents coordinate across tools, vendors, and organizations. That shift only works if the agents share a common language. The AI agent protocol stack provides that language — a set of open standards that define how agents connect to the world.
If your team is building or orchestrating AI agents with cowork.ink, understanding these protocols determines how your agents integrate with external services, collaborate with each other, and scale beyond a single workflow.
Why Protocols Matter for AI Agents
Without standards, connecting AI agents to tools creates an M×N problem: M agents multiplied by N tools equals an unmanageable number of custom integrations. Every new tool requires a bespoke connector for every AI application that wants to use it.
Protocols collapse this into M + N. Each agent implements one standard interface, and each tool exposes one standard server. The math becomes addition, not multiplication.
The same logic applies to agent-to-agent communication: if 100 specialist agents each use a different communication format, cross-vendor collaboration is impossible. Protocols make it trivial.
The Four Protocols at a Glance
| Protocol | Made by | Purpose | Status |
|---|---|---|---|
| MCP | Anthropic (Nov 2024) | Agent ↔ Tools & data | Production standard |
| A2A | Google + 50 partners (Apr 2025) | Agent ↔ Agent delegation | Growing fast |
| ACP | IBM / BeeAI (2025) | Agent ↔ Agent (local-first) | Merged into A2A |
| ANP | Open community (2024–25) | Agent ↔ Agent (open internet) | Experimental |
Both MCP and A2A are now governed by the Agentic AI Foundation (AAIF), a Linux Foundation project co-founded in December 2025 by Anthropic, OpenAI, Google, Microsoft, AWS, and Block. This vendor-neutral governance is a major signal of protocol maturity.
Model Context Protocol (MCP)
MCP connects a single agent to external tools and data sources. It solves the problem of how an agent accesses a database, runs code, performs a web search, or calls any external API — through one standardized interface rather than dozens of bespoke connectors.
Anthropic open-sourced MCP on November 25, 2024. By March 2026 it had reached 97 million monthly SDK downloads — growth comparable to React but in 16 months rather than three years. There are over 10,000 active public MCP servers today.
How it works:
- Built on JSON-RPC 2.0 over stdio (local) or HTTP (remote)
- Each MCP server exposes three primitives: Resources (data retrieval), Tools (actions with side effects), Prompts (reusable templates)
- Three roles: Host (the AI app), Client (the protocol layer), Server (the tool provider)
- Inspired by the Language Server Protocol — the same pattern that standardized IDE integrations
Think of MCP as USB-C for AI agents: one standard port that works with any compliant server.
We have a full guide to building your own MCP server and a curated list of the best MCP servers worth adding to your agent stack.
Agent-to-Agent Protocol (A2A)
A2A enables one agent to discover, delegate tasks to, and collaborate with another agent — regardless of which vendor built it or which framework it runs on.
Google launched A2A on April 9, 2025, with support from over 50 partners including Atlassian, LangChain, Salesforce, SAP, ServiceNow, and the major consulting firms. It is licensed under Apache 2.0.
How it works:
- Each A2A agent publishes an Agent Card — a JSON file at
/.well-known/agent-card.jsondescribing its capabilities, supported input/output modalities, authentication, and pricing - Client agents query Agent Cards to discover suitable collaborators before initiating tasks
- Task lifecycle:
submitted → working → input-required → completed / failed / cancelled - Transport: HTTP + Server-Sent Events for streaming, JSON-RPC, OpenAPI authentication
- Supports long-running asynchronous tasks (hours or days), not just synchronous exchanges
A2A is complementary to MCP. A delegating agent uses A2A to hand off a task to a specialist agent; that specialist then uses MCP internally to call the tools it needs. For a deeper comparison, see our MCP vs A2A guide.
Agent Communication Protocol (ACP)
ACP was IBM's answer to local-first, HTTP-native agent coordination — a simpler REST-based protocol optimized for low latency and privacy within enterprise environments.
Developed under the Linux Foundation's BeeAI project, ACP prioritized developer ergonomics: pure REST with no special libraries, session-aware messaging, multipart MIME content support, and built-in observability via OpenTelemetry.
In August 2025, ACP merged into A2A. IBM's team joined the A2A Technical Steering Committee, and BeeAI migrated to A2A. ACP's developer-friendly REST patterns directly shaped A2A's current design. If you encounter ACP references in older documentation or tutorials, treat them as pointing toward A2A today.
Agent Network Protocol (ANP)
ANP is the most ambitious layer: a decentralized peer-to-peer protocol that lets agents find and communicate with each other across the open internet — without a central registry or authority.
Where MCP and A2A assume a known set of participants, ANP asks: how does an agent that has never encountered another agent discover and trust it? Its answer involves three layers:
- Identity — Cryptographic identity via W3C Decentralized Identifiers (DIDs), so no central party controls who is a valid agent
- Meta-protocol — Agents negotiate communication format before they communicate
- Application — Capability descriptions using JSON-LD for semantic interoperability
ANP's stated vision is "the HTTP of the agentic web." It is currently experimental — high negotiation overhead and complex implementation make it better suited for pioneering pilots than production deployments.
How the Stack Fits Together
The four protocols form a clear hierarchy:
- AI model runtime (Claude, GPT-4o, Gemini, Llama) — the thinking layer
- MCP — connects each agent to tools, APIs, and data
- A2A — connects agents to other agents across org and vendor lines
- ANP — connects agents to the open, decentralized agent internet
These layers are independent. A single agent can receive a task via A2A, execute it using several MCP tool calls, and report back — all without the coordinating agent knowing which tools were used. This separation of concerns is what makes the stack composable and scalable.
For teams building multi-agent collaboration or AI agent orchestration systems, the practical path today is: implement MCP for tool access and A2A for agent delegation, with ANP on the roadmap as the ecosystem matures.
Which Protocol Should You Use?
| If you need... | Use |
|---|---|
| An agent to call tools, APIs, or databases | MCP |
| Two agents to delegate tasks to each other | A2A |
| ACP integrations from existing systems | Migrate to A2A |
| Decentralized open-internet agent discovery | ANP (experimental) |
| Tool access + agent collaboration together | MCP + A2A |
For most production engineering teams, the answer is MCP + A2A together. MCP handles the vertical integration (agent to resources); A2A handles the horizontal integration (agent to agent). A 2025 academic survey on agent interoperability protocols recommends a phased adoption path: MCP first, then A2A as coordination requirements grow, with ANP for future open-network scenarios.
Both MCP and A2A have attack surfaces worth understanding before deploying in production. See our MCP security best practices and AI agent security guides.
Get Started
The AI agent protocol stack is standardizing fast. MCP is already the de facto tool-access standard; A2A is rapidly becoming the same for agent collaboration. Teams that adopt both now are building on the same foundation that will power the agentic web.
cowork.ink is built for engineering teams who want to orchestrate AI agents across their workflows — code review, planning, documentation — without building protocol infrastructure from scratch. Create your workspace and deploy your first agent in minutes.