What is the Agent Client Protocol (ACP)?
Zed's open standard lets any coding agent talk to any editor: JSON-RPC over stdio, reusing MCP's JSON types. Who supports it, how it differs from MCP, and which of the three “ACPs” you've met.
The Agent Client Protocol (ACP) is an open, Apache-2.0 standard that lets any coding agent talk to any editor or app that speaks it, the way the Language Server Protocol did for language tooling. Created by Zed Industries and announced in August 2025 with Google’s Gemini CLI as the first reference implementation, it runs the agent as a subprocess and talks JSON-RPC over stdio, reusing MCP’s JSON representations where possible. A year on it has real pull: JetBrains ships official ACP support, the protocol’s own directory lists OpenClaw, Hermes, Goose, and Gemini CLI among its agents, and Block’s Buzz workspace uses it to seat agents in team channels. One caution before you search further: two other protocols also go by “ACP.”
Three protocols share the name: here’s your map
“What is ACP” is a genuinely ambiguous question in 2026, and half the answers you’ll find describe a different thing:
- Agent Client Protocol (this page,
agentclientprotocol.com): Zed’s standard connecting agents to the programs you drive them from: editors, IDEs, and increasingly chat surfaces. - Agent Communication Protocol (
agentcommunicationprotocol.dev): a REST-based agent-to-agent interop standard developed under the Linux Foundation alongside IBM’s BeeAI. Its own site now says plainly: “ACP is now part of A2A under the Linux Foundation”: it merged into the Agent2Agent effort, so new work happens there. - Everything else: outside software, “ACP” most famously means Automatic Colt Pistol, which is why a bare search mixes ammunition catalogs into protocol docs.
If someone says an agent or an app “speaks ACP” in 2026 (Buzz, Zed, JetBrains, Hermes), they almost always mean the Agent Client Protocol.
What it standardizes, mechanically
The protocol’s framing is deliberately LSP-shaped: before LSP, every editor needed a custom integration for every language; before ACP, every editor needed a custom integration for every agent. ACP decouples the two so each side can, in the project’s words, innovate independently. Concretely: the client (an editor, or any host program) spawns the agent as a subprocess and the two exchange JSON-RPC over stdio: session setup, prompts, streamed responses, tool activity, file diffs, terminal commands, and permission requests all have standard shapes. Where a concept already existed in MCP, ACP reuses the same JSON representation rather than inventing a rival one, and it adds the types coding UIs actually need, like structured diffs. The current stable protocol version is 1, with official SDKs for TypeScript, Python, Rust, Kotlin, and Java. Remote transport (HTTP/WebSocket) is documented as work in progress. Today’s deployments are overwhelmingly local subprocess ones.
ACP and MCP are complements, not rivals
The Model Context Protocol connects an agent to its tools and data: filesystems, databases, APIs. ACP connects the agent to the human’s front-end. A single Hermes or OpenClaw process can hold MCP connections to a dozen tool servers while itself being driven over ACP by Zed, a JetBrains IDE, or a Buzz channel. If you’re deciding what to learn: MCP shapes what your agent can do, ACP shapes where you sit while directing it.
Who actually supports it
On the client side: Zed natively, JetBrains’ official AI Assistant, Qt Creator via a plugin, and a wide community layer: multiple VS Code extensions, three Neovim plugins, Emacs’s agent-shell, Obsidian plugins, even Jupyter and marimo notebook integrations. On the agent side, the protocol’s directory lists more than thirty implementations including Gemini CLI, Goose, Hermes, OpenClaw, OpenCode, OpenHands, Qwen Code, and GitHub Copilot (in public preview), with Claude Code and Codex CLI reachable through Zed’s adapters. Two entries matter for agent operators specifically: Hermes ships hermes acp as a first-class server mode, and Block’s Buzz workspace uses a bridge (buzz-acp) to put any ACP agent into a team channel, the first mainstream case of ACP escaping the code editor.
Why it matters if you run an agent
ACP quietly changes what “where does my agent live” means. An agent that speaks it stops being married to one UI: the same process on the same machine, with its memory and state intact, can be driven from a laptop editor today and a team workspace tomorrow. One caveat from the Hermes docs worth knowing anywhere ACP runs headless: bridges have to answer the protocol’s permission requests themselves, because no editor is present to show an approval dialog, so a headless ACP deployment is only as safe as the permission policy of whatever is doing the bridging.