What is ACP?
ACP most often means the Agent Client Protocol, an open standard from Zed that lets a code editor run a coding agent as a subprocess and talk to it over JSON-RPC on stdio, the way LSP connects editors to language servers. A second, unrelated ACP, IBM's Agent Communication Protocol, has been folded into A2A.
Part of Glossary: the terms behind MCP, coding agents and shared pages, defined plainly.
Your editor starts the agent as a subprocess when you pick it, and the two exchange JSON-RPC messages over the agent's stdin and stdout.
They begin with initialize to agree on what each side can do, then the editor opens a session with session/new.
Each message you type reaches the agent as session/prompt; the agent streams progress back as session/update notifications.
When the agent wants to run a tool or edit a file, it asks through session/request_permission and the editor shows you the approval.
The editor can lend the agent its file system and terminals (fs/read_text_file, terminal/create) and pass along your MCP server settings.
ACP versus the other ACP
Two protocols share the acronym, and they solve different problems.
The Agent Client Protocol comes from Zed Industries, who announced it in August 2025 with Google's Gemini CLI as the first reference implementation. It sits between a code editor and a coding agent. The problem it fixes is combinatorial: without a standard, every editor builds a custom integration for every agent, and every agent learns every editor's API. ACP borrows the idea from the Language Server Protocol. The editor stays the place you work, and the agent becomes a swappable component behind one wire format.
The Agent Communication Protocol was IBM's REST-based protocol for agents talking to other agents, built alongside BeeAI and donated to the Linux Foundation. Its own site now says it is part of A2A. If you are reading about agent-to-agent messaging, that is the ACP you want, and A2A is the live project. Everything below is about the editor protocol.
Example: Gemini CLI inside Zed
You open Zed's agent panel and pick Gemini CLI. Zed launches the CLI as a child process and sends initialize, then session/new. You type "add a retry to the upload function". Zed forwards that as session/prompt. As the agent reads files and reasons, it sends session/update notifications, which Zed renders as the usual streaming transcript, including diffs in the editor's own diff view rather than in a terminal. When the agent wants to write the file, it sends session/request_permission; Zed shows you Allow or Deny. The turn ends when the agent answers the prompt with a stop reason.
The same agent, unchanged, runs inside JetBrains AI Assistant, Neovim's CodeCompanion or Emacs's agent-shell, because they all speak the client side of the protocol. JetBrains keeps custom agents in ~/.jetbrains/acp.json as a command plus arguments, which is really all an ACP client needs to know.
Why it matters
The useful detail is which side owns what. The editor owns the UI, your files and your terminals, and can offer them to the agent as methods (fs/read_text_file, fs/write_text_file, terminal/create). The agent owns the model loop and its tools. MCP is layered on top: the editor hands the agent your configured MCP servers, and the agent connects to them itself. So an agent running under ACP can still reach a remote MCP server such as Intraface's and publish a board, while the approval prompt for that tool call appears in your editor.
Remote agents, hosted elsewhere and reached over HTTP or WebSocket, are described as work in progress on the protocol site. Today the common shape is local: a subprocess on your machine, JSON-RPC over stdio.
Common mistakes
- Expecting ACP to replace MCP. They are different layers. One moves prompts and permissions between you and the agent; the other moves tool calls between the agent and services.
- Assuming any CLI agent works. The agent has to implement the protocol. Several appear through adapters, such as the Claude Agent entry built on Zed's SDK adapter and Codex CLI through ACP's own adapter.
- Confusing the two ACPs in a design doc. Say "Agent Client Protocol" at least once. Half your readers will picture IBM's protocol otherwise.
FAQ
- Is ACP the same thing as MCP?
- No. MCP connects an agent to tools and data. ACP connects an editor to an agent. An agent can sit in the middle of both: it receives your prompts over ACP and calls tools over MCP. ACP reuses MCP's JSON types where it can and adds its own for things like showing diffs.
- Which editors and agents support ACP?
- Zed created the protocol and JetBrains AI Assistant supports it, with Neovim, Emacs, VS Code and others through plugins. The ACP site lists agents including Gemini CLI, Codex CLI, Goose, OpenCode, Cline, Qwen Code, Kiro CLI and a Claude Agent adapter.
- Is IBM's ACP the same as the Agent Client Protocol?
- No. IBM's Agent Communication Protocol was a REST-based protocol for agents talking to each other, built for BeeAI under the Linux Foundation. It has since become part of A2A, so searches for "ACP" today mostly lead to Zed's editor protocol.
Stop sending HTMLover Slack.
Create an account in a minute, connect your coding agent, and make your first board.