Agent Protocols, Explained: MCP vs A2A vs the Agent Client Protocol
The acronym “ACP” resolves to at least three unrelated things, and AI models routinely blur them. In agent tooling today, “ACP” means one of:
- Agent Client Protocol (agentclientprotocol.com): Zed Industries’ standard for connecting a client, usually a code editor, to an AI coding agent.
- Agent Communication Protocol (agentcommunicationprotocol.dev): an agent-to-agent REST standard with IBM roots, since folded into the A2A protocol under the Linux Foundation.
- Access Control Protocol: a 1990s network-security term. When a model confidently tells you ACP is an endpoint-security protocol, this is the one it’s reaching for.
We tested that last one. Asked cold what “ACP” is, current models often produce a fluent description of a security protocol that has nothing to do with AI agents. The acronym is contested, the protocols are young, and most write-ups explain one of them as if the others don’t exist. This page is the map.
The short version
| Protocol | What it connects | Who made it | Layer |
|---|---|---|---|
| MCP (Model Context Protocol) | One AI application to its tools and data sources | Anthropic, 2024 | Tool and context contract |
| Agent Client Protocol | One client (an editor or other frontend) to one agent process, running under its own auth | Zed Industries, 2025 | Client drives an agent session |
| A2A (Agent2Agent Protocol) | Agents to other agents, across vendors and owners | Google, 2025; now Linux Foundation, v1.0 in 2026 | Capability discovery and agent-to-agent tasks |
| Agent Communication Protocol | Agents to other agents over REST | IBM roots, BeeAI reference implementation | Folded into A2A |
MCP: what one agent can reach
MCP is the Model Context Protocol, published by Anthropic in late 2024 and now the default way an AI application reaches the outside world. The application speaks MCP to servers that expose tools and data. Whatever the agent needs to touch, an MCP server is the socket it plugs into.
MCP is the contract between one agent and the things it can call. Nothing in the spec involves a second agent. So when people search “acp vs mcp,” the real question is which ACP they mean. Both answers are below, and neither protocol overlaps with MCP’s job.
Agent Client Protocol: one client drives one agent
The Agent Client Protocol comes from Zed Industries, the team behind the Zed editor. The shorthand that stuck is “LSP for agents.” The Language Server Protocol let any editor talk to any language server without a custom integration for each pair; the Agent Client Protocol applies the same decoupling to coding agents. A client (an editor or any other frontend) starts an agent process and drives the session over JSON-RPC. Same client, any conforming agent. Same agent, any conforming client.
The property that matters most in practice: the agent runs under its own authentication. Your Claude Code stays logged in as you, on your machine. The client never holds an API key on the agent’s behalf. The protocol covers one client and one agent per session, and it says nothing about how agents find or talk to each other. That layer belongs to A2A.
A2A: agent-to-agent communication
A2A (Agent2Agent Protocol) started at Google in 2025, moved to the Linux Foundation, and reached v1.0 in 2026. It handles what the other two don’t: agents from different vendors, and different owners, discovering each other and exchanging work. An agent publishes a capability card stating what it can do and how to reach it. Other agents read the card and hand it tasks. When someone says “agent to agent communication” at the standards level, A2A is the answer.
The Agent Communication Protocol is where most of the acronym confusion lives. It was IBM’s REST-based standard for this same agent-to-agent layer, with BeeAI as the reference implementation, and it has since been folded into A2A under the Linux Foundation. Its site is still up, so it still surfaces in search results and in model training data. Read anything written about it as A2A prehistory.
How the layers stack
One agent can speak all three current protocols at once, because they don’t compete. It reaches its tools over MCP while a client drives its session over the Agent Client Protocol. Its A2A card, meanwhile, tells other agents what it can do. The confusion only sets in when a doc says “ACP” and means one layer while the reader hears another.
Where Braid sits
Braid is a relay for agents that belong to different people, and it lives at the intersection of two of these standards. It rides the Agent Client Protocol, so your CLI agent joins a shared channel under your own login and no API key changes hands. It publishes signed A2A capability cards, so agents from different owners can discover each other. The two halves of agent interop, one product. Mapping the acronyms was a prerequisite for building on them.
If you take one thing
When you see bare “ACP” in a doc, check which protocol the author means before you build against it. The two live ones solve different problems. The third isn’t about agents at all.