What is Agent Client Protocol?

An open protocol that lets AI coding agents communicate with editors and IDEs in a standardized way, so the same agent can run inside Cursor, Devin Desktop, Zed, or any other compliant client.

Agent Client Protocol | The Wise Operator

What It Is

Agent Client Protocol (ACP) is an open standard, modeled loosely on the Language Server Protocol and the Model Context Protocol, that lets AI coding agents speak to editors and IDEs without each one needing a custom integration. Where LSP let any language server work with any editor, ACP lets any agent, whether Codex, Claude Agent, OpenCode, or Devin Local, run inside any ACP-compliant client. Cognition put ACP at the center of Devin Desktop on June 2, 2026 when it relaunched the Windsurf IDE under the Devin name and made agent portability the headline feature.

The protocol is not the agent. It is the wire format and the lifecycle around the agent. ACP defines how an editor opens a session with an agent, hands it context such as open files, cursor position, and diagnostics, receives partial outputs as the agent thinks, and applies the agent’s edits back into the workspace. The agent itself stays whatever it is: a model from OpenAI, Anthropic, or an open-weights provider. The protocol makes the agent’s body, not its brain, portable.

How It Actually Works

An ACP session has three pieces: a client (the IDE), an agent (a long-running process), and a transport (usually stdio or a local socket). The client spawns the agent as a subprocess, then exchanges JSON-RPC messages over the transport. The client sends events like session/start, file/open, cursor/move, and user/message. The agent sends events like thought/partial, edit/proposed, tool/use, and session/complete.

Both sides can stream. The agent does not block on a single round trip; it sends partial thoughts and proposed edits as it reasons, and the client renders them in the editor in real time. The client can interrupt at any point, send a corrective message, or revoke a proposed edit. The protocol is intentionally close to how a human pair-programmer would actually communicate, which is why it borrows so much from chat-style streaming rather than the request-response shape of older completion APIs.

Why It Matters Right Now

The agent layer is becoming the strategic layer in the AI coding stack. A year ago, the IDE was the moat: Cursor competed with VS Code, which competed with JetBrains. The model was a swap. Today the model is becoming the moat: an OpenAI Codex user wants Codex inside whatever IDE they prefer, and an Anthropic Claude Agent user wants Claude inside whatever IDE they prefer. ACP is the protocol that makes the IDE a commodity again and reasserts the agent as the differentiator. Cognition shipping it as the default in Devin Desktop signals that the IDE makers themselves see this coming and would rather host the agents than be replaced by them.

A Concrete Operator Scenario

You are running a small consulting team. Three engineers prefer Cursor. Two prefer Vim. One uses Zed. Last year, standardizing on Copilot meant standardizing on VS Code, which the Vim users refused. This year, with ACP, you standardize on Claude Agent, and the protocol carries it into each engineer’s editor of choice. The same agent reviews the same code with the same prompt history regardless of who is reading the result. The conversations you have at standup about agent behavior are now about the agent, not about whose editor returned what.

How TWO Uses It

TWO’s view is that ACP matters more to the non-developer reader than it sounds. The protocol layer is what decides whether the agent you use at work is the agent your employer chose or the agent you chose. In a Copilot-bound IDE, the employer’s contract decides. In an ACP-bound IDE, the engineer can swap Claude for Codex for OpenCode on Tuesday and back again on Wednesday without changing tools. That kind of portability is the difference between an agentic-coding future where every developer is locked into one vendor’s stack and one where the agent is closer to a freelancer the operator hires per job.

The operator decision is therefore not which agent to buy. It is whether the stack you are building on is closed to the agent the vendor sold you, or open to the agent you will hire next year. If you are picking an IDE for a team this quarter, the ACP question is the question. Tools that ship ACP, like Devin Desktop and Zed, let your operating posture move with the market. Tools that ship a single proprietary agent, like the current default Copilot configuration, mean the agent you got is the agent you have.

What to Watch Next

The signal that ACP is winning is when a vendor not aligned with Cognition adopts it. JetBrains, VS Code, and Microsoft Copilot are the obvious tests. If any of them ship ACP support in the next two quarters, the protocol is the standard. If they hold the line on proprietary agent integration, ACP stays a Cognition-led ecosystem and the agent-layer market consolidates around whoever owns the IDE. The other watch is whether Anthropic or OpenAI release first-party ACP-compatible agents alongside their existing APIs; both have hinted at it, neither has shipped it as of June 2026.

ACP sits next to MCP, the Model Context Protocol, which standardizes how models reach tools and data. Where MCP is about giving the model hands, ACP is about giving the agent a body the editor can hold. Together they form the open protocol layer that agentic-coding is being built on, and they sit underneath the agent-control-surface where operators actually see what the agents are doing.