Agent Client Protocol (ACP): run any coding agent in your editor

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.

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.

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.json that follows the repository’s agent.schema.json, and an icon.svg: 16 by 16, one color, using currentColor.
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 initialize to agree on a protocol version and capabilities.
The editor calls session/new for a working directory.
The editor sends your message with session/prompt.
The agent streams session/update notifications: text, tool calls and their status, plans, diffs.
Before a gated action, the agent calls session/request_permission and the editor shows you the choice.
The turn ends with a stopReason: end_turn, max_tokens, max_turn_requests, refusal or cancelled. You can stop it early with session/cancel.

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.

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.

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.

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.

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