Agent-to-Agent Communication Protocols: A2A vs ACP vs MCP Compared

The agentic AI stack in 2026 runs on three protocol acronyms — MCP, A2A, and ACP — yet most teams still treat them as interchangeable buzzwords. They are not. Each protocol targets a different layer of the communication stack, and understanding where one ends and the next begins is the difference between a clean architecture and a tangle of shims. This article maps the landscape, examines how ACP’s merger into A2A reshaped the field, and shows how Codex CLI practitioners can wire these protocols into production workflows.

The Three Protocols at a Glance

Aspect	MCP	A2A	ACP
Purpose	Agent-to-tool connectivity	Agent-to-agent collaboration	Agent communication (merged into A2A)
Created by	Anthropic (Nov 2024)	Google (Apr 2025)	IBM Research (2025)
Current status	Active — spec 2025-11-25 ¹	Active — v1.0 (early 2026) ²	Merged into A2A (Aug 2025) ³
Transport	JSON-RPC over Streamable HTTP	JSON-RPC 2.0 over HTTPS + SSE	REST/HTTP (historical)
Governance	Linux Foundation (Dec 2025) ¹	Linux Foundation (Jun 2025) ²	N/A

The shorthand: MCP connects agents to tools; A2A connects agents to agents. ACP no longer exists as a standalone specification.

MCP: The Tool Connectivity Layer

Anthropic’s Model Context Protocol acts as a universal adapter between an LLM-powered agent and external systems — databases, APIs, SaaS platforms, file systems ⁴. Think of it as USB-C for AI tooling.

Core Primitives

MCP servers expose three primitive types to clients:

Tools — callable functions with typed input/output schemas
Resources — read-only data endpoints (files, database rows, API responses)
Prompts — reusable prompt templates with arguments

Clients expose three primitives back to servers:

Sampling — server-initiated LLM inference requests (now with tool use support as of spec 2025-11-25) ⁵
Roots — workspace root URIs the client has access to
Elicitation — structured data collection from the human user ⁵

Transport

The current spec mandates Streamable HTTP as the recommended remote transport, replacing the earlier SSE-based approach ¹. Local servers still use stdio, where the host process launches the MCP server as a child process communicating via stdin/stdout.

MCP in Codex CLI

Codex CLI configures MCP servers in config.toml:

# ~/.codex/config.toml — global MCP server
[mcp_servers.github]
type = "url"
url = "https://api.githubcopilot.com/mcp/"
headers = { Authorization = "Bearer ${GITHUB_TOKEN}" }

[mcp_servers.filesystem]
type = "command"
command = ["npx", "-y", "@anthropic/mcp-filesystem-server", "/home/dev/project"]

The codex mcp CLI subcommand manages server lifecycle, and project-scoped servers can be defined in .codex/config.toml for trusted projects ⁶.

Scale Considerations

The 2026 roadmap acknowledges production gaps: horizontal scaling behind load balancers, stateless operation patterns, enterprise-managed auth with SSO integration, and audit trail observability ⁷. These are being addressed but are not yet in the stable spec.

A2A: The Agent Collaboration Layer

Google’s Agent-to-Agent Protocol solves a fundamentally different problem: how do autonomous agents — potentially built by different vendors, running in different organisations — discover each other, delegate tasks, and exchange results? ²

Agent Cards

Every A2A server publishes a JSON document at /.well-known/agent.json describing its capabilities:

{
  "name": "contract-review-agent",
  "description": "Reviews legal contracts for compliance issues",
  "skills": [
    {
      "id": "contract-review",
      "description": "Analyse contract clauses against regulatory requirements",
      "inputModes": ["text/plain", "application/pdf"],
      "outputModes": ["text/markdown"]
    }
  ],
  "authentication": {
    "schemes": ["bearer"]
  },
  "supportsStreaming": true
}

Agent Cards enable automated discovery: a client agent can crawl a registry of known endpoints, read their cards, and decide which remote agent is best suited for a subtask ⁸.

Task Lifecycle

Tasks are the unit of work in A2A. They follow a defined state machine:

stateDiagram-v2
    [*] --> submitted
    submitted --> working
    working --> input_required
    input_required --> working
    working --> completed
    working --> failed
    working --> canceled
    completed --> [*]
    failed --> [*]
    canceled --> [*]

The input_required state is particularly important — it preserves human-in-the-loop workflows across agent boundaries, allowing a remote agent to pause and request clarification from the calling agent or its human operator ⁸.

Transport

A2A uses JSON-RPC 2.0 over HTTPS with Server-Sent Events for streaming ². The primary methods are:

tasks/send — non-streaming request
tasks/sendSubscribe — streaming with event subscriptions
tasks/get — state polling
tasks/cancel — task termination

Choosing HTTP as the transport was deliberate: it slots into existing enterprise infrastructure — load balancers, firewalls, mTLS termination, and OpenTelemetry instrumentation — without requiring custom networking ⁸.

Adoption

As of April 2026, over 150 organisations support A2A, including Google, Microsoft, AWS, Salesforce, SAP, ServiceNow, Workday, and IBM ². Native A2A support ships in Google ADK, LangGraph, CrewAI, LlamaIndex Agents, Semantic Kernel, and AutoGen ².

ACP: A Protocol Absorbed

IBM Research launched the Agent Communication Protocol in 2025 as a lightweight, REST-native alternative to A2A. ACP prioritised simplicity: plain HTTP verbs, minimal ceremony, and fast adoption for teams already running REST microservices ³.

Why It Merged

Maintaining two agent-to-agent standards created unnecessary fragmentation. In September 2025, IBM announced that ACP would officially merge into A2A under the Linux Foundation ³. Kate Blair, IBM’s Director of Incubation overseeing ACP, joined the A2A Technical Steering Committee, and the ACP team began contributing technology directly to A2A ³.

This was not abandonment — ACP’s best ideas (REST simplicity, lightweight messaging patterns) are folded into A2A’s roadmap. Migration documentation was provided for existing ACP users ³.

Practical Impact

If you built on ACP, the migration path is straightforward: replace ACP endpoints with A2A task methods, convert your service manifest to an Agent Card, and adopt JSON-RPC 2.0 transport. The conceptual model — agents as opaque services with discoverable capabilities — remains identical.

The Layered Architecture

In production, these protocols are complementary, not competing. A well-architected agent system uses both:

graph TB
    subgraph "Agent A — Codex CLI"
        A[LLM Agent] --> MCP_A[MCP Client]
        MCP_A --> T1[GitHub MCP Server]
        MCP_A --> T2[Database MCP Server]
        MCP_A --> T3[File System MCP Server]
        A --> A2A_C[A2A Client]
    end

    subgraph "Agent B — Contract Review"
        B[LLM Agent] --> MCP_B[MCP Client]
        MCP_B --> T4[Legal DB MCP Server]
        B --> A2A_S[A2A Server]
    end

    A2A_C -->|"tasks/send"| A2A_S

    style A fill:#2d5016,color:#fff
    style B fill:#2d5016,color:#fff

Each agent is both an MCP client (accessing its own tools) and an A2A client or server (collaborating with peer agents). This mirrors traditional enterprise service design: individual services manage their own data stores (MCP) while communicating with peers through a shared protocol (A2A) ⁹.

Bridging MCP and A2A

An emerging pattern is the A2A-MCP bridge: an MCP server that wraps an A2A client, exposing remote agents as callable tools within the MCP tool registry. From the LLM’s perspective, invoking a remote agent looks identical to calling a local tool:

# Expose a remote A2A agent as an MCP tool
[mcp_servers.contract_reviewer]
type = "command"
command = ["a2a-mcp-bridge", "--agent-url", "https://legal.internal/.well-known/agent.json"]

This pattern lets Codex CLI orchestrate multi-agent workflows without requiring native A2A support in the CLI itself ⁹.

Protocol Selection Decision Tree

flowchart TD
    START[What are you connecting?] --> Q1{Agent to external<br/>tool or data source?}
    Q1 -->|Yes| MCP[Use MCP]
    Q1 -->|No| Q2{Agent to another<br/>autonomous agent?}
    Q2 -->|Yes| Q3{Same organisation<br/>and framework?}
    Q3 -->|Yes| Q4{Simple REST<br/>sufficient?}
    Q4 -->|Yes| A2A_LIGHT[Use A2A with<br/>minimal Agent Cards]
    Q4 -->|No| A2A_FULL[Use A2A with<br/>streaming + auth]
    Q3 -->|No| A2A_FULL
    Q2 -->|No| DIRECT[Direct API call<br/>— no protocol needed]

What About ANP?

The Agent Network Protocol (ANP) targets a fourth layer: cross-network agent discovery across the open internet, using DID-based identity and verifiable credentials ¹⁰. It remains early-stage and is not yet production-relevant for most teams, but it is worth monitoring as the protocol stack matures.

Practical Recommendations for Codex CLI Users

Start with MCP. Every Codex CLI workflow benefits from MCP server integration. Configure your essential tools (GitHub, databases, documentation) as MCP servers first.
Add A2A when you need agent delegation. If your workflow requires handing subtasks to specialist agents — code review, security scanning, contract analysis — adopt A2A for that communication layer.
Use the bridge pattern. Wrap A2A agents as MCP tools to keep Codex CLI as the single orchestration point. This avoids protocol complexity leaking into your agent prompts.
Ignore ACP. If you encounter ACP references in older documentation, treat them as historical. Migrate to A2A.
Watch the MCP 2026 roadmap. Enterprise features (audit trails, SSO-integrated auth, stateless scaling) are coming but not yet stable ⁷. Plan accordingly.

Citations

“MCP Specification 2025-11-25”, Model Context Protocol, modelcontextprotocol.io/specification/2025-11-25 ↩ ↩² ↩³
“A2A Protocol Explained: How Google’s Agent-to-Agent Standard Grew to 150+ Organizations in One Year”, Stellagent, 2026, stellagent.ai/insights/a2a-protocol-google-agent-to-agent ↩ ↩² ↩³ ↩⁴ ↩⁵ ↩⁶
“ACP Joins Forces with A2A”, Linux Foundation AI & Data, August 2025, lfaidata.foundation/communityblog/2025/08/29/acp-joins-forces-with-a2a ↩ ↩² ↩³ ↩⁴ ↩⁵
“Model Context Protocol”, Wikipedia, en.wikipedia.org/wiki/Model_Context_Protocol ↩
“MCP 2025-11-25 is here: async Tasks, better OAuth, extensions, and a smoother agentic future”, WorkOS, workos.com/blog/mcp-2025-11-25-spec-update ↩ ↩²
“Model Context Protocol — Codex CLI”, OpenAI Developers, developers.openai.com/codex/mcp ↩
“MCP’s biggest growing pains for production use will soon be solved”, The New Stack, 2026, thenewstack.io/model-context-protocol-roadmap-2026 ↩ ↩²
“Google’s A2A Protocol — The Complete Agent-to-Agent Guide”, Rapid Claw, 2026, rapidclaw.dev/blog/a2a-protocol-complete-guide-2026 ↩ ↩² ↩³
“MCP vs A2A vs ACP: The 2026 Guide to AI Agent Communication Protocols”, OptInAmPout, 2026, optinampout.com/blogs/mcp-vs-a2a-vs-acp-agent-protocols-2026 ↩ ↩²
“Agentic AI Protocols Comparison: MCP vs A2A vs ACP vs ANP”, K21 Academy, k21academy.com/agentic-ai/agentic-ai-protocols-comparison ↩