The Agent Client Protocol (ACP) is an open standard that lets a coding agent run inside a code editor. Any editor that speaks ACP can run any agent that speaks it: Claude, Codex, OpenCode, Cursor, Goose and dozens more inside Zed, JetBrains IDEs, Neovim or Emacs, with no custom plugin for each pair. It is not IBM’s Agent Communication Protocol, also called ACP, which connected agents to each other and merged into Google’s A2A protocol in August 2025.
For OpenCode, configure your editor to launch opencode acp. If the chosen provider needs a login, run opencode auth login before starting the editor session. The ACP process waits for the editor on standard input. OpenCode ACP setup
What it looks like in practice
Without ACP, every agent needs its own plugin for every editor. An agent’s makers build a VS Code extension, then a JetBrains plugin, and maybe never get to Zed or Emacs; if your editor isn’t on their list, the agent runs in a separate terminal next to it.
With ACP, you open your editor’s agent panel and pick the agent from a list. You type the task there. The agent’s tool calls, its plan and its file diffs stream into the panel, and when it wants to run a command, the editor asks you. Switching to a different agent is a menu choice; your editor, keybindings and project stay the same.
How do I use an agent in my editor?
The fastest way is the ACP registry, a shared list of agents your editor can install for you.
Zed: run zed: acp registry from the Command Palette and install an agent. It then appears in the new-thread menu of the Agent Panel.
JetBrains IDEs: open the AI Chat tool window, open the chat mode selector and choose Install From ACP Registry, or go to Settings | Tools | AI Assistant | Agents. The IDE downloads the agent and any Node.js or Python runtime it needs. ACP agents do not need a JetBrains AI subscription, and they do not run inside WSL.
On first use, most agents ask you to sign in or enter an API key.
For an agent that is not in the registry, add it by hand. In Zed, run agent: open settings, go to External Agents, click Add Agent and choose Add Custom Agent. Zed opens your settings with an entry like this:
{
"agent_servers": {
"my-agent": {
"type": "custom",
"command": "node",
"args": ["~/projects/agent/index.js", "--acp"],
"env": {}
}
}
}
In JetBrains IDEs, click ⋯ in the AI Chat tool window and choose Add Custom Agent. The IDE opens ~/.jetbrains/acp.json:
{
"agent_servers": {
"Example Agent": {
"command": "/path/to/agent",
"args": ["acp"]
}
}
}
Use the full path to the agent program in command. The IDE starts it as a subprocess and may not see your PATH.
The connection-test trap: a passing connection check proves that the agent starts and answers the handshake, not that a session works. When an earlier Contenox build was wired into AionUi, Test Connection reported success while every real prompt failed with “Agent disconnected”: the session path added a launch flag the probe never sent, and that build rejected it. Send one real prompt before trusting a new entry.
Which editors and agents support ACP?
The protocol site keeps the current lists. As of November 2026:
- Editors with built-in support: Zed and JetBrains IDEs.
- Through plugins or extensions: Neovim (CodeCompanion, avante.nvim and others), Emacs (agent-shell.el), VS Code (community extensions such as ACP Client), Visual Studio, Sublime Text, Qt Creator and Obsidian, among others.
- Agents: Gemini CLI, GitHub Copilot, Cursor, Cline, Goose, OpenCode, Junie, Qwen Code, Mistral Vibe, Factory Droid and many more.
- Through adapters: Claude (
@agentclientprotocol/claude-agent-acp) and Codex CLI (@agentclientprotocol/codex-acp). An adapter is a small program that translates between ACP and an agent’s own interface. - Apps that host agents: not every ACP client is an editor. The Contenox desktop app has an Agents page where you add any ACP agent by name, command and arguments, with a preset for Claude Code.
VS Code is listed only through extensions, so install one before you look for ACP agents there.
What is the ACP registry?
The registry is a curated list of ACP agents, published as one JSON file that editors read to offer one-click install. Zed and JetBrains launched it together in January 2026, and both have it built in.
The registry only lists agents that support sign-in: a check confirms that each agent returns valid authentication methods in the ACP handshake. An hourly job checks npm, PyPI and GitHub releases, so the registry tracks each agent’s latest version.
To get an agent listed:
- Fork github.com/agentclientprotocol/registry.
- Create a folder named after your agent’s ID, lowercase with hyphens.
- Add an
agent.jsonthat follows the repository’sagent.schema.json, and anicon.svg: 16 by 16, one color, usingcurrentColor. - Open a pull request. The repository’s CONTRIBUTING.md has the details.
Once merged, the agent shows up in every editor that reads the registry.
How is ACP different from MCP?
They sit on opposite sides of the agent, and you will often use both:
| Connects | Carries | |
|---|---|---|
| ACP | Editor ↔ agent | Your prompt, the agent’s streamed output, diffs, permission requests |
| MCP | Agent ↔ tools and data | Tool calls such as “create issue” or “query database” |
ACP reuses MCP’s JSON formats where it can. When the editor opens a session, it can pass along the MCP servers you configured, so the agent can use them. In JetBrains IDEs, that is the Pass custom MCP servers option.
How is ACP different from A2A?
A2A, Google’s Agent2Agent protocol, lets agents call other agents across services. IBM’s Agent Communication Protocol did similar work; in August 2025 its team stopped active development and merged it into A2A under the Linux Foundation. Neither is about editors. If you are wiring a coding agent into an IDE, the ACP you want is the Agent Client Protocol.
How does ACP work?
For a local agent, the editor starts the agent as a subprocess and the two exchange JSON-RPC messages over standard input and output. Remote agents over HTTP or WebSocket are part of the design, but the docs call full remote support a work in progress.
A session runs like this:
- The editor calls
initializeto agree on a protocol version and capabilities. - The editor calls
session/newfor a working directory. - The editor sends your message with
session/prompt. - The agent streams
session/updatenotifications: text, tool calls and their status, plans, diffs. - Before a gated action, the agent calls
session/request_permissionand the editor shows you the choice. - The turn ends with a
stopReason:end_turn,max_tokens,max_turn_requests,refusalorcancelled. You can stop it early withsession/cancel.
A client that cannot show approvals still has to answer step 5. An earlier Contenox editor integration showed why a clean reject-once beats a “method not found” error: well-behaved agents read the error as a broken client, while a rejection lets the agent report the denial and end its turn on its own terms.
A prompt request:
{
"jsonrpc": "2.0",
"id": 2,
"method": "session/prompt",
"params": {
"sessionId": "sess_abc123def456",
"prompt": [{ "type": "text", "text": "Add a unit test for parseDate" }]
}
}
The prompt is a list of content blocks, so the editor can attach a file as a resource block alongside the text.
Implementations are stricter or looser than the spec in practice. Building a terminal client showed that the official TypeScript SDK’s validator treats some fields as required that real agents do not always send, such as a tool call’s title, and silently drops the whole notification when one is missing; its web client therefore used the SDK for its types only and owned its own message loop.
If the editor offers the capability, the agent can also work through it: fs/read_text_file and fs/write_text_file read and write files, including unsaved buffers, and terminal/create with its companion methods runs commands in an editor terminal.
Clients differ in what they offer. Wiring one agent into three clients for an earlier Contenox build showed the spread: Zed ran shell commands in a live, interactive editor terminal, while GoLand and AionUi did not advertise the terminal capability, so the command still ran and its output landed in the tool card. The config dialects differ too: Zed’s entry carries "type": "custom", the JetBrains acp.json has no such field.
What ACP does not do
- It does not choose the model. The agent does.
- It does not enforce permissions. It gives the agent a way to ask. Whether risky actions are gated depends on the agent and the editor. See AI agent permissions.
- It does not sandbox anything. A local agent runs as a normal process with your user’s access.
- It does not make agents equal. Some agents support more of the protocol than others, such as reopening past sessions or showing plans. If a feature is missing in the panel, check the agent before blaming the editor.
Seen in a real client: the rule belongs in the agent, not in the client. A terminal client built on ACP turned out to know almost nothing about the agent it talked to, which is the protocol working as designed; but wherever that client enforced a rule itself, the rule held only while that client was running, and the same session opened from a browser had none. The fix was to make every gated call a recorded question the agent waits on, answered once from whichever client. The account is in terminal client for AI agents.
Where ACP came from
Zed started ACP in August 2025 with Google’s Gemini CLI as the first agent and published it under the Apache license. JetBrains joined later that year, and the two launched the registry in January 2026. The idea follows the Language Server Protocol: LSP let any editor support any programming language, and ACP does the same for coding agents.
Related guides
- What is MCP?: the protocol for the agent’s tools
- What is an AI coding agent?: what runs on the other end of ACP
- AGENTS.md explained: project instructions that work in every agent
- AI agent permissions: what to allow, ask and block