The Agent Client Protocol came up twice while I was writing up ai-coworkers: once as the thing Zed builds its agent panel on, and again as the mechanism Buzz uses to let agents join a workspace. This post is what I found reading the spec and the surrounding announcements:
- What ACP standardises and how the wire protocol works
- Where adoption stands, from the registry to the VS Code holdout
- How Buzz uses it to make agents teammates
- Where it fits next to MCP, and what that means for a coworker runtime
The LSP move, repeated
ACP was created by Zed Industries and released in August 2025. The pitch copies LSP deliberately: instead of every editor integrating every agent (N x M integrations), each side implements one protocol (N + M). An editor that implements it gets every ACP agent, and an agent that implements it runs everywhere.
The mechanics are also LSP-shaped. A local agent runs as a subprocess of the client and they exchange JSON-RPC 2.0 over stdio. User-facing text defaults to Markdown so clients do not need an HTML renderer. Remote agents over HTTP and WebSocket are still work in progress, tracked by a Transports working group.
What the protocol covers
The stable v1 protocol splits into a small set of concerns:
- Initialization, where the two sides exchange capabilities and implementation metadata
- Session setup, with stabilised methods including
session/list,session/delete,session/close, andsession/resume - The prompt turn, the core conversation flow between client and agent
- Tool calls, where the agent reports execution progress back to the client
- Permission requests, so the client (and its human) can gate what the agent does
- File system and terminal methods, letting the agent read the client’s world and run commands through it
The last group carries the design choice that matters most for my purposes: the agent does not get its own filesystem access, it asks the client. Which means the client is the enforcement point for what an agent may touch, the same conclusion I reached from a different direction with BOUNDARIES.md in ai-coworkers.
A v2 draft is published for review, reworking the prompt turn into a fuller prompt lifecycle and moving filesystem and terminal execution into a revised client surface.
Adoption in 2026
What changed this year:
- The ACP Registry launched with JetBrains in January: register an agent once, and every ACP client can list and launch it. Claude Code, Codex CLI, GitHub Copilot CLI, OpenCode, and Gemini CLI are all in it.
- Over 25 agents supported the protocol by March, per the community progress report.
- ACP was the headline feature of Zed 1.0 in April, and JetBrains IDEs have shipped it since December 2025.
- The main holdout is VS Code. Microsoft standardised its agent mode on MCP instead, and as of March had not committed to native ACP support, leaving community extensions to fill the gap.
Buzz: ACP outside the editor
Buzz is the first big use of ACP that has nothing to do with editing code in a buffer. Block’s workspace treats agents as team members with their own keypairs, and the way an agent joins a channel is via ACP. Claude Code, Codex, and Block’s own Goose all connect through the same protocol, on identical footing.
That widens what counts as an ACP client, from editors and IDEs to a chat workspace. The protocol carries sessions, prompts, tool calls, and permissions whether the surface is a code buffer or a channel.
Where this touches ai-coworkers
Two conclusions for my own project.
First, ACP is the obvious wire for the coding coworker. ai-coworkers has a scaffolded code.delegate action that needs a real coding agent behind it. Rather than shelling out to one specific CLI, speaking ACP as a client would let a coworker delegate implementation work to whichever registered agent the operator prefers, and the permission-request flow maps cleanly onto the runtime’s boundary checks.
Second, the division of labour between the protocols is settling. MCP connects a model to tools. ACP connects a client to an agent, and reuses MCP’s JSON representations where possible rather than inventing new ones. A coworker runtime sits on both sides: it consumes MCP servers as tools, and it could expose or consume ACP as the way agents plug into larger surfaces, the way they already plug into Buzz.