Agent Client Protocol (ACP): The Open Standard for AI Coding Agents

What Is the Agent Client Protocol?

The Agent Client Protocol (ACP) is an open standard that defines how AI coding agents communicate with code editors. Created by Zed Industries and released in August 2025, it uses JSON-RPC 2.0 over stdin/stdout to create a universal interface between agents and editors.

Before ACP, every agent-editor combination required a custom integration. Claude Code worked in VS Code. Gemini worked in Gemini's own interface. Goose required a bespoke Neovim plugin. ACP standardizes the interface so any compatible agent works in any compatible editor, no custom glue code required.

The closest analogy is the Language Server Protocol. Before LSP, every editor needed its own TypeScript parser, Python linter, and Go formatter. After LSP, one language server worked everywhere. ACP does the same for AI agents.

ACP vs MCP: What's the Difference?

ACP and MCP are frequently confused because both involve AI agents and use JSON-RPC. They solve different problems and are designed to work together, not compete.

The Simple Mental Model

MCP answers: "What tools and data can the agent access?" ACP answers: "Where does the agent live in the developer's editor?"

When an ACP session starts, the editor passes available MCP server endpoints and credentials to the agent. The agent then invokes tools via MCP calls, all piped through the ACP session. The two protocols are complementary layers in the same stack.

Which Editors Support ACP?

Editor support varies. Zed has the most complete implementation as the protocol's origin. JetBrains is adding native support. Neovim and Emacs rely on community plugins. VS Code has community extensions but no native support.

Zed's Native Support

Zed spawns agents as subprocesses and communicates over stdin/stdout. The editor passes codebase context (file tree, open files, terminal output) to the agent at session start. Agents stream token-by-token responses back to Zed's UI in real time.

VS Code: Why No Native Support?

Microsoft has standardized VS Code's agent mode on MCP rather than ACP. The open GitHub issue (#265496) requests native ACP support, but as of March 2026 Microsoft has not committed to adding it. Community extensions fill the gap for developers who want ACP agents in VS Code.

Which Agents Support ACP?

Over 25 agents support ACP as of March 2026. Google's Gemini CLI was the first external integration. GitHub Copilot CLI added ACP support in January 2026.

How ACP Works

ACP uses a subprocess model. When you activate an agent, your editor spawns it as a child process and communicates over stdin/stdout using JSON-RPC 2.0. This is the same transport mechanism LSP uses, which means ACP can run anywhere LSP runs.

The Five Core Message Types

Every ACP session uses five baseline messages:

1. session/initialize: Agent declares its capabilities and protocol version.
2. session/new: Editor creates a new conversation session.
3. session/prompt: Editor sends a user prompt to the agent.
4. session/update: Agent streams a response back to the editor.
5. session/cancel: Editor halts agent processing mid-response.

Permission Model

Agents cannot execute arbitrary commands. When an agent wants to run a terminal command or write a file, it sends a session/request_permission message to the editor. The editor (and by extension, the user) approves or denies each action. This keeps the user in control even during autonomous runs.

Protocol Version and Extensibility

ACP uses a single integer version number (PROTOCOL_VERSION = 1) that only increments for breaking changes. Non-breaking additions happen through capability negotiation at initialization. Custom extensions use underscore-prefixed method names and _meta fields, keeping the core protocol stable while allowing experimentation.

Getting Started with ACP

In Zed

Open Zed's agent panel and select an ACP-compatible agent from the dropdown. Zed ships with Gemini CLI and Claude Code (via adapter) pre-configured. For other agents, add them in your settings.json:

{
  "agent": {
    "profiles": {
      "my-goose-agent": {
        "provider": "acp",
        "command": "goose",
        "args": ["run", "--acp"]
      }
    }
  }
}

In Neovim

Install agentic.nvim using your plugin manager:

{
  "carlos-algms/agentic.nvim",
  config = function()
    require("agentic").setup({
      default_agent = "claude-code",
      agents = {
        ["claude-code"] = {
          command = "claude",
          args = { "--acp" },
        },
        ["gemini"] = {
          command = "gemini",
          args = { "--acp" },
        },
      },
    })
  end,
}

Building an ACP Agent in Python

Use the official Python SDK to build ACP-compatible agents:

pip install agent-client-protocol

# echo_agent.py
import asyncio
from acp import Agent, Session

class EchoAgent(Agent):
    async def on_prompt(self, session: Session, prompt: str) -> str:
        # Stream a response back to the editor
        await session.stream_text(f"You said: {prompt}")
        return "done"

if __name__ == "__main__":
    asyncio.run(EchoAgent().run_stdio())

Building an ACP Agent in TypeScript

npm install @agentclientprotocol/sdk

import { createAcpAgent } from "@agentclientprotocol/sdk";

const agent = createAcpAgent({
  name: "my-agent",
  version: "1.0.0",
  onPrompt: async (session, prompt) => {
    // Read a file from the editor
    const file = await session.readFile("/src/index.ts");
    // Stream partial responses
    await session.streamText(`Processing: ${file.path}`);
    return "done";
  },
});

agent.run(); // starts stdio loop

What Developers Are Saying

ACP hit Hacker News multiple times between October 2025 and early 2026, accumulating significant discussion across threads about the protocol's announcement, JetBrains adoption, and community tooling.

"Rather than integrating each one individually, we built a protocol that any agent could implement. We also hoped it would help the broader ecosystem: agents could stay focused on logic while editors handled UX, giving developers real choice instead of being locked into specific tool combinations."

Nathan Sobo, CEO of Zed Industries, on why they built ACP

The Goose team at Block described ACP as solving the "three-app problem": developers previously had to juggle an editor, an AI agent window, and a browser simultaneously. ACP collapses the agent into the editor, removing one app from the workflow entirely.

On Hacker News, the JetBrains ACP thread (December 2025) drew comments noting that enterprise Java and Kotlin developers, who have been reluctant to switch editors, would now have access to the full ACP agent ecosystem without leaving IntelliJ. This is ACP's main growth driver: it brings the agent ecosystem to editors with large existing userbases, not just to Zed.

Community Tooling

Beyond official implementations, the community has built several ACP tools:

• Acpex: An Elixir CLI for ACP, allowing agent interactions from the terminal with any ACP agent.
• acp-ai-provider: Vercel AI SDK community provider for ACP, enabling web-based ACP clients.
• obsidian-agent-client: Brings Claude Code, Codex, and Gemini into Obsidian via ACP.

Frequently Asked Questions

What is the Agent Client Protocol?

ACP is an open standard by Zed Industries that defines how AI coding agents communicate with code editors. It uses JSON-RPC 2.0 over stdin/stdout. Any ACP-compatible agent works in any ACP-compatible editor without custom integrations.

Is ACP replacing MCP?

No. They solve different problems. MCP (Anthropic's Model Context Protocol) handles tool and data access. ACP handles agent-editor integration. The two work together: when an ACP session starts, the editor passes MCP server endpoints to the agent so it can use both simultaneously.

Does Claude Code support ACP?

Claude Code works in ACP editors via a bridge adapter built by Zed. Anthropic has not natively adopted ACP, but the bridge wraps Claude Code so it communicates over ACP. You can use Claude Code in Zed, Neovim, and Emacs through this adapter.

Does VS Code support ACP?

No native support as of March 2026. Community extensions (vscode-acp) add partial support. An open GitHub issue (#265496) tracks the request for native integration. Microsoft has standardized VS Code's agent mode on MCP instead.

How is ACP different from LSP?

Both use JSON-RPC 2.0 over stdin/stdout. LSP standardizes language features (autocomplete, go-to-definition) between editors and language servers. ACP standardizes AI agent interaction (prompts, sessions, file permissions, streaming) between editors and coding agents. ACP is the LSP equivalent for AI agents.

How do I use ACP with Python?

Install the Python SDK: pip install agent-client-protocol. The SDK requires Python 3.10+ and provides async base classes, stdio JSON-RPC transport, and helper builders. Quickstart at agentclientprotocol.github.io/python-sdk.

Which editor has the best ACP support?

Zed has the most complete support since it created the protocol. JetBrains is adding native support in partnership with Zed. Neovim and Emacs have stable community plugins. VS Code has limited community extension support.

What agents support ACP?

Natively: Gemini CLI, GitHub Copilot CLI (public preview), Goose, Cline, OpenHands, Mistral Vibe, Auggie, and Blackbox AI. Via adapter: Claude Code, Codex CLI. In progress: Aider. The full list is at agentclientprotocol.com/overview/agents.