Agent Client Protocol (ACP): How It Works in 2026
The Agent Client Protocol (ACP) lets a code editor run any compatible coding agent without a custom integration for each pair. Zed released it in August 2025. JetBrains joined as a co-developer that October, and Cognition's Devin Desktop now runs third-party agents over it. If you build an agent or pick an editor, ACP decides which combinations work. Below you will see how a session runs and where ACP sits next to MCP. Memory is the part ACP leaves to each agent.
What is the Agent Client Protocol, in one sentence?
The Agent Client Protocol is an open JSON-RPC standard for communication between code editors and the coding agents running inside them.
Zed's Nathan Sobo announced it on August 27, 2025, with Google's Gemini CLI as the first reference implementation. The protocol is Apache-2.0 licensed. Its GitHub repository lists official SDKs for Kotlin, Java, Python, Rust and TypeScript, and gives the current stable protocol version as 1. The name collides with the older Agent Communication Protocol, a separate project for agent-to-agent messaging.
How does ACP differ from MCP?
MCP connects an agent to tools and data. ACP sits on the other side of the agent and connects it to the editor.
| Agent Client Protocol (ACP) | Model Context Protocol (MCP) | |
|---|---|---|
| Connects | An editor or other client to a coding agent | An agent or app to tools and data sources |
| Who calls whom | The editor sends prompts, the agent streams back edits and tool calls | The agent calls the server's tools |
| Typical transport | JSON-RPC over stdio for local agents, HTTP or WebSocket for remote | stdio or HTTP |
| Example | Running Codex CLI inside Zed or IntelliJ IDEA | Giving an agent a GitHub or database server |
The transport details come from the ACP introduction, which says ACP reuses MCP's JSON types where it can. It adds its own types for things like diff display.
When an editor opens an ACP session, it passes the agent a list of MCP servers to connect to. Your editor's MCP setup can then follow you to whichever agent you pick.
How does an ACP session work?
A local agent runs as a subprocess of the editor and talks over standard input and output. Remote agents can use HTTP or WebSocket, though the introduction notes that full remote support is still a work in progress.
The session setup spec defines the lifecycle. The client calls session/new with a working directory and the MCP server list, and the agent must return a unique session ID. From there the editor sends prompts and the agent streams back its messages and proposed diffs for the editor to render. A client can also pass extra directories if the agent advertises support for them.
Returning to old work is optional. An agent that advertises the loadSession capability supports session/load, and it must then replay the entire conversation to the client. That is how an editor redraws an old chat after a restart. A separate resume capability restores the session without replaying history, which suits a client that already has the transcript on screen. A close method cancels running work and frees the session. In every case the editor only displays the history the agent sends.
Which editors and agents support ACP?
Zed and JetBrains announced their partnership on October 6, 2025. JetBrains said it would bring ACP across its IDE lineup, including IntelliJ IDEA. Neovim and Emacs have community clients. Devin Desktop, the renamed Windsurf editor, runs third-party agents over ACP, per Cognition's launch post.
On the agent side, the protocol site's agent list had 48 entries when we checked. They include Gemini CLI, GitHub Copilot, Cursor, Goose and OpenCode. Some connect through adapters: Codex CLI uses an ACP adapter, and Anthropic's agent runs through Zed's adapter for the Claude Agent SDK. The client list covers editors from Sublime Text to Visual Studio, though several entries are community plugins.
Distribution got simpler with the ACP Registry, which went live on January 28, 2026. An agent that already speaks ACP gets listed by following the submission guide and opening a pull request. Once it merges, the agent appears in every client with registry support. At launch that meant Zed and JetBrains IDEs, and Zed credits JetBrains with pushing the registry spec forward.
What does ACP leave out?
ACP standardizes the conversation between editor and agent. Instructions and memory stay with each agent, and the session spec sets no format for the history the agent stores and replays.
Switching agents in the same editor therefore loses the earlier session. Run Claude through ACP in the morning and Codex in the afternoon, and the second agent has none of the first one's conversation. Only your MCP server list carries over, because the editor sends it again. Instruction files do not help much either, since each agent reads its own.
Remote agents are still marked as in progress. Session load and resume are optional capabilities, so support varies by agent. Many clients and adapters on the official lists are community projects, and the lists are self-reported. We did not test them.
The bottom line
Coding agent authors should implement ACP and submit the agent to the registry. One integration then reaches Zed and the JetBrains IDEs, plus any other client with registry support. If you use several agents, ACP lets you switch between them in one editor. Plan separately for what those agents remember, because the protocol does not carry it.
How do you share memory across agents when ACP only shares the connection?
Because session/load replays history only from the agent that recorded it, a task handed from Codex to Claude in Zed arrives with none of the earlier context. Corrections you made in one agent's session have to be repeated in the next.
memU keeps memory as a shared wiki of readable Markdown that sits outside any single agent. A scheduled background task slices new session logs from each host into jobs, which the agent distills into memory and skill Markdown. A standing instruction in CLAUDE.md or AGENTS.md tells the agent to retrieve before it answers. memU itself makes no LLM calls. It stores and retrieves the Markdown the agent prepared, with embeddings for search.
All hosts share one backend, so what Codex learned is available to Claude Code. Host and mode support is listed in the matrix in the memU GitHub repository. The hosted version is free and syncs across devices. Get an API key from memu.so and send your agent one message:
Read https://memu.pro/SKILL.md, follow its instructions to install and configure memU, API Key is
YOUR_MEMU_API_KEY.
FAQ
Who created the Agent Client Protocol?
Zed created ACP and announced it on August 27, 2025, with Gemini CLI as the first agent. JetBrains became a co-developer in October 2025.
Can I use my MCP servers with ACP agents?
Yes. The editor passes its MCP server list to the agent in session/new, and the agent connects to those servers itself.
Does Claude Code work with ACP?
Yes, through an adapter. Zed maintains an adapter built on the Claude Agent SDK, and the ACP Registry lists Claude Code among its agents.
Is ACP the same as the Agent Communication Protocol?
They are separate projects. The Agent Client Protocol connects editors to coding agents, and the Agent Communication Protocol handles messaging between agents.
Does ACP store conversation history?
The protocol does not store anything itself. Agents that support session/load keep their own history and must replay the full conversation to the editor on request.