Protocols: MCP vs A2A vs ACP

Three protocols define how AI agents connect to the world - each solving a different problem.

The Three-Protocol Landscape

+------------------+     +------------------+     +------------------+
|    MCP           |     |    A2A           |     |    ACP           |
|  (Anthropic)     |     |  (Google)        |     |  (IBM/BeeAI)    |
|                  |     |                  |     |                  |
| Agent <-> Tools  |     | Agent <-> Agent  |     | Agent <-> Agent  |
| (vertical)       |     | (horizontal)     |     | (brokered)       |
+------------------+     +------------------+     +------------------+

MCP connects an agent to tools and data sources (vertical integration). A2A connects agents to other agents as peers (horizontal collaboration). ACP also connects agents, but through a central broker (enterprise orchestration).

These are complementary, not competing. A production system might use MCP for tool access and A2A for agent-to-agent delegation.

MCP (Model Context Protocol)

Created by Anthropic, November 2024. Now the dominant standard for tool integration.

What it solves

Before MCP, every AI tool integration was custom. Want Claude to read files? Custom code. Want it to query a database? Different custom code. MCP standardizes this into a universal protocol.

Architecture

AI Application (Host)
    |
    | JSON-RPC over stdio/SSE/HTTP
    |
MCP Server (exposes tools, resources, prompts)
    |
    | Native integration
    |
External System (DB, API, filesystem, etc.)

• Host - the AI app (Claude Desktop, Claude Code, VS Code, etc.)
• Client - maintains a 1:1 connection with a server
• Server - exposes capabilities via a standard interface

What servers expose

Key characteristics

• JSON-RPC 2.0 transport over stdio (local) or SSE/HTTP (remote)
• Stateful sessions with capability negotiation
• Server-initiated notifications (resources can push updates)
• Human-in-the-loop built in (approval flows for sensitive operations)

Example: MCP tool definition

{
  "name": "create_github_issue",
  "description": "Create an issue in a GitHub repository",
  "inputSchema": {
    "type": "object",
    "properties": {
      "repo": { "type": "string" },
      "title": { "type": "string" },
      "body": { "type": "string" }
    },
    "required": ["repo", "title"]
  }
}

Where MCP is used

• Claude Desktop, Claude Code (native)
• VS Code Copilot (via MCP server support)
• Cursor, Windsurf, Zed (IDE integrations)
• GitHub Agentic Workflows (tool source)

A2A (Agent2Agent Protocol)

Created by Google, April 2025. Now under Linux Foundation governance. ACP merged into A2A in late 2025.

What it solves

MCP connects an agent to tools. But what if you need two agents to collaborate - a research agent delegating to a coding agent? A2A handles agent-to-agent communication where each agent is opaque (you don’t see inside it).

Architecture

A2A Client (app, service, or agent)
    |
    | HTTP + JSON-RPC + SSE
    |
A2A Server (remote agent)
    |
    | Internal logic (opaque)
    |
Agent's tools, models, etc.

Core concepts

Agent Card (discovery)

Agents publish a JSON document at /.well-known/agent.json:

{
  "name": "code-review-agent",
  "description": "Reviews code for security and quality issues",
  "url": "https://agents.example.com/code-review",
  "capabilities": {
    "streaming": true,
    "pushNotifications": true
  },
  "skills": [
    {
      "id": "security-review",
      "name": "Security Review",
      "description": "Scans code for OWASP top 10 vulnerabilities"
    }
  ]
}

Task lifecycle

submitted -> working -> completed
                    \-> failed
                    \-> input_required (needs human input)
                    \-> canceled

Key characteristics

• HTTP + JSON-RPC (same web standards as everything else)
• gRPC support added in 2026 for high-throughput scenarios
• Opaque agents - you send tasks, get results, don’t see internals
• Streaming via SSE for long-running tasks
• Enterprise auth - parity with OpenAPI authentication schemes
• 50+ partners including Salesforce, SAP, LangChain, PayPal

When to use A2A vs MCP

ACP (Agent Communication Protocol)

Created by IBM’s BeeAI. Merged into A2A in September 2025 under the Linux Foundation. No longer actively developed as a separate protocol.

What it was

ACP was a REST-native agent-to-agent protocol with:

• OpenAPI-based specification
• Async-first design (ideal for long-running tasks)
• Multi-modal message support (text, files, structured data)
• Client-server architecture with centralized broker option

Why it matters

Even though ACP merged into A2A, its concepts influenced the combined protocol:

• The async-first design pattern carried over
• Enterprise patterns (HA, Redis/PostgreSQL storage) informed A2A’s enterprise features
• The TypeScript SDK contributed to A2A’s multi-language support

Current status

If you’re building new systems, use A2A. ACP documentation is historical context only.

Protocol Comparison

The Practical Mental Model

Think of it like a company:

• MCP = giving an employee access to internal tools (Slack, Jira, databases)
• A2A = that employee collaborating with employees at other companies
• Your SDK = how you build the employee (their brain, skills, personality)

You need MCP and A2A together. MCP for vertical integration (tools), A2A for horizontal integration (other agents). Your SDK (Claude, OpenAI, Copilot) provides the agent runtime that uses both.