MCP, A2A, ACP Explained: How Agents Connect to Tools, Other Agents, and Clients

Protocol Overview

The Model Context Protocol (MCP), Agent‑to‑Agent Protocol (A2A) and Agent Client Protocol (ACP) address distinct layers of an AI‑agent system. MCP standardises how an agent accesses tools, A2A enables discovery and collaboration between agents, and ACP defines how external clients invoke agents. Their scopes are mutually exclusive.

MCP – Model Context Protocol (Agent ↔ Tool)

What it is

An open protocol led by Anthropic, released late 2024, that defines a USB‑C‑like universal interface for AI agents to connect to external tools.

Problem it solves

Before MCP each tool required a bespoke adapter (e.g., separate code for GitHub, databases, search engines). Switching AI front‑ends forced a complete rewrite of those adapters.

Architecture

MCP Server – implemented by the tool developer to expose capabilities.

MCP Client – embedded in the AI application (e.g., Claude Desktop, Cursor) to consume the server.

MCP Host – the AI application itself that hosts the client.

The server can expose three primitive types:

Tools – model‑driven functions such as "get weather" or "execute SQL".

Resources – data that the AI reads passively, like file contents or database records.

Prompts – user‑driven workflow templates, e.g., a code‑review template.

Code example

# FastMCP example exposing a weather tool
from mcp.server.fastmcp import FastMCP

mcp = FastMCP("Weather")

@mcp.tool()
async def get_weather(city: str) -> str:
    """Return the weather for the specified city"""
    return f"{city}: sunny, 28°C"

With roughly ten lines of code the weather tool becomes callable from any MCP‑compatible client (Claude Desktop, Cursor, VS Code, Windsurf) without modification.

Typical scenario

A team implements an internal API‑query tool as an MCP server; developers using Cursor, Claude Desktop, or VS Code can invoke it directly, eliminating duplicated adapters.

SDK coverage

Official SDKs for TypeScript, Python, Java, Kotlin and C#. Community SDKs add Go, Rust and Swift. Hundreds of ready‑made servers for databases, APIs and file operations are available on GitHub.

Scope

✅ Agent → Tool – managed by MCP

❌ Agent → Agent – out of scope

❌ Client → Agent – out of scope

A2A – Agent‑to‑Agent Protocol (Agent ↔ Agent)

What it is

An open protocol spearheaded by Google, released early 2025, that defines how an agent discovers another agent’s capabilities and coordinates work.

Problem it solves

In large systems agents often need to call agents built by different teams, using different frameworks (e.g., LangGraph vs. Crew AI). Without a common protocol each pair requires a custom HTTP interface and its own contract.

Core concepts

Agent Card – a JSON description of an agent’s abilities, used for discovery.

Task – lifecycle management (submitted, running, completed, failed).

Message – the dialogue exchanged between agents.

Part – a content block inside a message (text, file, structured data).

Agent Card example

{
  "name": "Background Check Agent",
  "description": "Verify candidate work experience and education",
  "url": "https://hr-tools.example.com/agents/background-check",
  "capabilities": {"streaming": true, "pushNotifications": false},
  "skills": [
    {"id": "verify-employment", "name": "Employment verification"},
    {"id": "verify-education", "name": "Education verification"}
  ]
}

The calling agent reads the Agent Card, confirms the required capability, then creates a Task. This mirrors a human checking a colleague’s business card before assigning work.

Scope

✅ Agent → Agent – managed by A2A

❌ Agent → Tool – out of scope (handled by MCP)

❌ Client → Agent – out of scope (handled by ACP)

ACP – Agent Client Protocol (Client ↔ Agent)

What it is

An open protocol originated by the Coder community, currently driven by open‑source contributors, that standardises how IDEs, CLIs or web front‑ends invoke an agent.

Problem it solves

Different agent frameworks expose different invocation APIs (LangGraph thread/run, Crew AI kickoff, Deep Agents invoke/ainvoke). A client built for one framework must be rewritten for another.

Core concepts

Agent – the server‑side agent instance.

Client – the caller (IDE plugin, CLI tool, web UI).

Session – a conversational context that maintains state.

Prompt – the request sent to the agent.

Communication model

ACP uses JSON‑RPC over either stdio or HTTP. The direction is opposite to MCP:

MCP: Agent → Tool (agent acts as client).

ACP: Client → Agent (agent acts as server).

JSON‑RPC initialization example

{
  "jsonrpc": "2.0",
  "method": "initialize",
  "params": {
    "protocolVersion": "0.1.0",
    "clientCapabilities": {
      "fs": {"readTextFile": true},
      "terminal": true
    }
  },
  "id": 1
}

The client sends initialize; the agent replies with its capability list. Subsequent steps (create Session, send Prompt, receive streaming response) follow the same protocol.

Scope

✅ Client → Agent – managed by ACP

❌ Agent → Tool – out of scope (handled by MCP)

❌ Agent → Agent – out of scope (handled by A2A)

Combined View

Who connects to whom : MCP (Agent ↔ Tool), A2A (Agent ↔ Agent), ACP (Client ↔ Agent).

What each solves : tool standardisation, agent discovery/collaboration, and agent service exposure.

Leadership : Anthropic (MCP), Google (A2A), Coder community (ACP).

Communication style : MCP – client‑server (stdio/HTTP); A2A – request‑response/streaming (HTTP); ACP – JSON‑RPC (stdio/HTTP).

Maturity : MCP – high (v1.0 released); A2A – medium (spec published, early ecosystem); ACP – low (community‑driven, few implementations).

Layered Interaction Example

User asks an IDE, "Show production error logs" – the request travels via ACP to an Operations Agent.

The Operations Agent determines it needs database access and uses A2A to locate a Database Agent.

The Database Agent invokes a log‑query tool via MCP, retrieves the data, and returns it.

The result propagates back through the same layers to the IDE.

Practical Recommendations

MCP : highest priority – already stable (v1.0), wide SDK support, many ready‑made servers.

ACP : monitor progress – adopt once the SDK stabilises.

A2A : consider only when your system truly requires cross‑framework agent collaboration.

Key Resources

MCP – documentation: https://modelcontextprotocol.io/ – Python SDK: https://github.com/modelcontextprotocol/python-sdk A2A – specification: https://google.github.io/A2A/ – Python SDK (community): https://github.com/themanojdesai/python-a2a ACP – documentation: https://agentclientprotocol.com/ – TypeScript SDK:

https://github.com/nichochar/acp