ACP one year in: the LSP for coding agents
ACP one year in: the LSP for coding agents
Zed's Agent Client Protocol went from a Gemini CLI side project to JetBrains' default and a public agent registry — with v2 now in draft.
Editors used to bind AI assistance directly into their own codebase, which meant one integration per agent, rebuilt every time a new model or CLI showed up. The Language Server Protocol solved the analogous problem for language tooling back in 2016: write one language server, and every LSP-speaking editor gets it for free. Zed's Agent Client Protocol does the same job for coding agents. Implement ACP once, and the agent runs inside any ACP-speaking editor without a bespoke plugin.
A year in, that bet looks like it paid off. Here's what actually shipped.
The timeline
| Date | Milestone |
|---|---|
| August 2025 | Zed launches ACP as an open, Apache-2.0 protocol under its "Bring Your Own Agent" feature, with Gemini CLI as the reference implementation |
| October 2025 | JetBrains partners with Zed to co-develop ACP and bring it across IntelliJ IDEA, PyCharm, WebStorm, and the rest of the IDE suite |
| January 28, 2026 | Zed and JetBrains jointly launch the ACP Registry, a shared directory for one-click agent install across both IDE families |
| April 22–29, 2026 | Zed ships Parallel Agents, then reaches 1.0 with ACP as its headline feature — multiple ACP agents running concurrently in one window |
| June 2, 2026 | Windsurf rebrands to Devin Desktop and ships ACP support, running Claude Agent, Codex, or OpenCode inside its Agent Command Center |
| July 20, 2026 | Zed publishes the first draft of ACP v2, reworking session handling while v1 stays wire-stable |
That's a fast climb for a protocol with a single corporate steward. The Model Context Protocol needed a foundation handoff to reach comparable reach; ACP got there mostly on the strength of Zed open-sourcing it early and JetBrains deciding to build on top of a rival's spec rather than write its own.
What actually connects
ACP is JSON-RPC 2.0 over stdio, which keeps it deliberately boring: no new transport to debug, no auth scheme to design, just requests and notifications between an editor process and an agent process it spawns. The editor sends the agent a workspace root and a permission surface (which tools it may call, which files it may touch); the agent streams back plan updates, diffs, and tool calls the editor renders in its own UI.
Native support today: Zed and JetBrains IDEs speak ACP directly. Neovim, Emacs, and VS Code get there through community plugins rather than first-party support — worth checking before you assume parity across editors.
On the agent side, the ecosystem is wider than the "Zed protocol" label suggests. Gemini CLI, GitHub Copilot CLI, Goose, Cline, OpenHands, and several other agents implement ACP natively; Claude Code and Codex CLI reach it through adapters rather than native support. The January registry exists precisely to paper over that distinction for users — install from a catalog instead of hand-wiring a stdio command.
The terminology trap
Searching "ACP" now mostly surfaces this protocol, which is worth flagging because the acronym is contested territory. IBM shipped an "Agent Communication Protocol" in March 2025 that merged into A2A five months later — see its entry in our tracker for that history. There's also an unrelated "Agent Control Protocol" for runtime admission control, and an "Agentic Commerce Protocol" in the payments space. None of them are this one. If a 2025 blog post mentions "ACP" without naming Zed or JetBrains, check which protocol it means before you cite it.
What v2 changes
The v2 draft is aimed at session semantics that the v1 design left awkward. In v1, an editor has two ways to reconnect to an existing agent session: session/load, which replays the full history back to the client, and session/resume, which reattaches without replaying anything. v2 collapses that into a single session/resume call, with an explicit replayFrom parameter — pass {"type": "start"} to get the old replay behavior, omit it to just reattach. It's a small change, but it's the kind of inconsistency that accumulates in any protocol built fast and iterated in public, and cleaning it up now is cheaper than carrying it into whatever ACP looks like at v3.
Compatibility is negotiated, not assumed: client and agent exchange a protocol version during initialize, and the wire shape follows whichever version both sides agreed on. Per the GitHub releases, the stable schema was at v1.20.0 as of July 21, 2026, with v2.0.0-alpha.2 shipping the same day on a parallel track — so v1 keeps getting maintenance releases while v2 is worked out in public, not a hard cutover.
Where this leaves you
If you're building a coding agent and want it usable outside your own CLI, ACP is the lowest-friction way to get into Zed and every JetBrains IDE at once — implement the stdio protocol, and the registry gives you discovery for free. If you're building an editor or IDE plugin, the same trade applies in reverse: speak ACP once instead of maintaining a bespoke integration per agent vendor.
The open question is the one every single-steward protocol carries: JetBrains buying in reduces but doesn't eliminate the governance risk of one company holding the spec. Nothing in this year's timeline suggests that's slowing adoption, but it's worth watching alongside AG-UI's similar situation on the frontend side of the stack.