What is the Agent Client Protocol (ACP)?

ACP is an Apache-licensed JSON-RPC protocol that standardizes communication between code editors (clients) and coding agents. Local agents typically run as a client subprocess over stdio. It is the editor↔agent counterpart to LSP, not a tool protocol and not an agent-to-agent protocol.

Is this the same ACP as IBM’s Agent Communication Protocol or Stripe’s Agentic Commerce Protocol?

No. IBM’s ACP was merged into A2A and archived. OpenAI/Stripe ACP is a commerce checkout standard. This site covers Zed-originated Agent Client Protocol at agentclientprotocol.com.

How is ACP different from MCP and LSP?

LSP connects editors to language servers. MCP connects models/agents to tools and data. ACP connects editors to coding agents, and reuses MCP JSON types where that saves work. Most serious setups use ACP and MCP together.

Should I implement v1 or v2?

v1 is the current stable wire protocol. v2 is a published draft: more consistent session state, upsert-style updates, and several breaking cleanups. Production software should speak v1 and only enable v2 behind version negotiation plus feature flags.

Which editors and agents support ACP?

Clients include Zed, JetBrains IDEs, Neovim plugins, VS Code extensions, Emacs, Obsidian, Qt Creator, and many desktop, mobile, and chat surfaces. Agents include Claude Agent and Codex via adapters, plus Gemini CLI, GitHub Copilot, Cursor, Grok Build, Goose, OpenCode, Junie, Qwen Code, Kimi CLI, and the rest of the registry.

Yes. The protocol, schema, official SDKs, and registry are developed in the open under Apache-2.0-style licensing. This website is an independent guide, not the canonical spec.

Open protocol · v1 stable · v2 draft

Agent Client Protocol (ACP) for AI Coding Agents

ACP is the LSP-like standard between code editors and coding agents. Local agents speak JSON-RPC over stdio. Remote HTTP and WebSocket transports are being standardized. This site is an independent ecosystem guide, not the official spec.

Explore clients & agents Read the protocol

Wire protocol

v1 stable

Ship this in production

Next major

v2 draft

Feature-flag only until it stabilizes

Authenticated agents

40 in registry

Curated catalog as of 12 Sep 2026

Official SDKs

TS & Rust 1.0

Plus Python, Java, Kotlin

Tired of building a custom integration for every editor-agent pair?

AI coding agents and editors are tightly coupled unless they share a protocol. Each new pairing becomes another plugin, another RPC shape, another week of glue.

Weeks wasted on glue

Every editor-agent pair starts from scratch: process lifecycle, streaming, permissions, diffs, and cancellation.

Your tools don't compose

Want Neovim + Claude, Zed + Codex, or JetBrains + Gemini? Without ACP you pick a vendor stack, not a workflow.

Vendor lock-in

Once the agent only speaks one editor's API, switching IDEs or trying a new agent means throwing the integration away.

ACP: implement once, connect everywhere

Like LSP for language servers, ACP gives agents one interface and editors one client. Compatible agents work in any ACP client; compatible editors get the whole agent ecosystem. MCP types are reused where they already fit.

How Agent Client Protocol works

The user stays in the editor. The client boots a local agent as a subprocess, or connects to a remote agent, then runs sessions over JSON-RPC.

JSON-RPC over stdio

JSON-RPC 2.0

Requests, responses, and notifications. Bidirectional: the agent can ask the client for permissions, files, terminals, or structured input.

MCP-friendly types

Content blocks, resources, and tool-call UX reuse MCP JSON where possible, then add coding-specific types such as diffs and plans.

Markdown by default

User-visible text is Markdown so clients can render rich output without shipping an HTML engine.

Real ACP method: session/prompt

{
  "jsonrpc": "2.0",
  "id": 2,
  "method": "session/prompt",
  "params": {
    "sessionId": "sess_abc123def456",
    "prompt": [
      {
        "type": "text",
        "text": "Refactor this function"
      }
    ]
  }
}

Sessions

initialize → authenticate if needed → session/new or session/load. v1 also stabilizes list, resume, close, and delete.

Streaming UX

Agents push session/update chunks for text, thoughts, tool calls, plans, slash commands, and usage.

Permissions & elicitation

Tool calls can require user approval. Stabilized elicitation collects structured forms or out-of-band URL flows.

Why teams adopt ACP

A shared contract beats N×M editor plugins — and it still leaves room for each product’s UX.

Universal compatibility

One agent binary can sit behind Zed, JetBrains, Neovim, VS Code extensions, and mobile or chat surfaces.

Capability negotiation

Optional features (loadSession, terminals, elicitation, config options) are advertised at initialize. Missing support is not a protocol break.

Developer freedom

Swap the editor or the agent without rewriting the other side.

Proven transport

Local stdio is production-ready. A Transports working group is standardizing streamable HTTP and WebSocket.

Stable SDKs

Official TypeScript and Rust SDKs reached 1.0. Python, Java, and Kotlin cover the rest of the official surface.

Extensibility

Custom methods use an underscore prefix. _meta carries extra data without breaking peers.

What people actually use ACP for

The protocol is the pipe. The product is still your editor UX and the agent’s tools.

In-editor coding agents

Refactor, write tests, and apply diffs with the same keybindings you already have.

Multi-agent workbenches

Run Claude, Codex, Gemini, and OpenCode as parallel sessions instead of parallel plugins.

Chat and mobile control planes

Drive a desktop agent from Telegram, Slack, WeChat, QQ, Lark, or a phone app.

Notebooks and data tools

Keep an agent next to Jupyter, marimo, or DuckDB without a one-off RPC.

Review and security loops

Permission prompts and tool-call cards keep file writes and shell commands in front of a human.

Custom harnesses

Frameworks such as Deep Agents, Koog, Mastra, and ACP Kit wrap existing runtimes as ACP agents.

Clients, agents, and the registry

The ecosystem is no longer “Zed plus a couple of CLIs”. Editors, IDEs, desktop apps, and 40 authenticated registry agents ship ACP today.

Editors & client surfaces

Zed

First-class external agent support

JetBrains IDEs

Built-in ACP client in AI Assistant

Visual Studio Code

ACP Client, ACP Pro, Multicoder, Poolside

Neovim

CodeCompanion, Avante, agentic.nvim, hermes.nvim

Emacs

agent-shell.el

Obsidian

Agent Client, Agent Console, Copilot, Harness

Agents & adapters

Claude Agent · claude-agent-acp 0.76

Codex · codex-acp 1.11

Gemini CLI 0.59 · GitHub Copilot CLI

Cursor · Grok Build · Goose · OpenCode · Junie

Qwen Code · Kimi CLI · Cline · Factory Droid

Need a specific pairing?

Compare client surfaces, adapters, registry entries, and capability support.

Open the compatibility guide

Guides on this site

We summarize the live protocol and ecosystem. Canonical schema and RFDs live on agentclientprotocol.com.

Protocol

The user stays in the editor. The client boots a local agent as a subprocess, or connects to a remote agent, then runs sessions over JSON-RPC.

Clients & Agents

The ecosystem is no longer “Zed plus a couple of CLIs”. Editors, IDEs, desktop apps, and 40 authenticated registry agents ship ACP today.

SDKs

Do not hand-roll JSON-RPC framing unless you are writing a new language binding. Official SDKs exist for both the client and agent sides.

Registry

The registry is how clients discover, install, and configure compatible agents without inventing their own manifest format. It is curated: agents must advertise authentication methods.

ACP vs MCP

If a search result says “ACP”, it might not mean this protocol. Agent Client Protocol is the editor↔coding-agent standard. It composes with MCP; it does not replace it.

GitHub

github.com/agentclientprotocol/agent-client-protocol

View on GitHub

Get started with ACP

Pick a side. Use v1 in production. Treat v2 as an opt-in draft.

For client / editor developers

Host agents, render updates, and gate dangerous tools behind permissions.

Read architecture and the v1 overview

Speak JSON-RPC over stdio first

Use an official SDK instead of hand-rolled framing

Advertise client capabilities and test against registry agents

Architecture guide

For agent developers

Implement the agent side once, then show up in every compatible client.

Handle initialize, session/new, and session/prompt

Stream session/update for text, tools, and plans

Advertise auth methods if you need login

Submit an authenticated agent to the ACP Registry

Session setup

Ready to wire an editor to an agent?

Start from v1, pick an SDK, and keep v2 behind a version check.

Get Started View on GitHub

Frequently asked questions

Short answers. Official schema always wins if this guide and the spec disagree.