← All resources

Agent Client Protocol (ACP): How Editors Talk to Coding Agents

Guide · updated 2026-10-11 · Markdown variant

Reference for the Agent Client Protocol (ACP), the open protocol that connects code editors and IDEs to coding agents over JSON-RPC: session lifecycle, MCP server hand-off, transports, tool calls, permissions, and how ACP differs from MCP and A2A.

The Agent Client Protocol (ACP) is an open protocol that standardizes communication between code editors or IDEs (the client) and coding agents (programs that use generative AI to modify code). This entry is about that protocol only: it is not the Agentic Commerce Protocol (Stripe and OpenAI; see /resources/agentic-payment-protocols). The acronym is also used by other protocols; this one is defined by the sources listed below.

Key facts

• Scope: editor/client <-> coding agent. MCP connects an agent to tools and data; A2A connects an agent to another agent. ACP sits at the editor-to-agent edge.
• Local agents run as a sub-process of the editor and talk JSON-RPC over stdio. ACP reuses MCP JSON representations where possible and adds custom types for coding UX such as diffs. The docs compare its role to the Language Server Protocol (LSP).
• The repository README states contributions are licensed under Apache-2.0. Official libraries listed there: Kotlin, Java, Python, Rust, TypeScript.
• The README states the current stable protocol version is 1. The docs navigation shows "Protocol v1 Latest" and a separate "v2 Draft": a v2 draft exists, and every method listed below is from the v1 pages.
• The agents page (https://agentclientprotocol.com/overview/agents) lists 41 agents as counted on 2026-10-11 (for example Claude Agent, Codex CLI, Gemini CLI, GitHub Copilot, Goose, Junie by JetBrains, Cline, OpenHands). The clients page (https://agentclientprotocol.com/overview/clients) lists, among others, Zed, JetBrains, Neovim (through a plugin), Emacs (agent-shell.el), Sublime Text (through the ACP plugin) and Visual Studio Code (through extensions).
• zed.dev/acp says ACP was created by Zed and grown by the community, with JetBrains and Zed collaborating on it.

What is the Agent Client Protocol?

Without a shared protocol each editor needs a bespoke integration per agent. ACP defines one JSON-RPC message vocabulary so any ACP-capable editor can drive any ACP-capable agent. The agent edits code and runs commands; the editor owns the UI, renders streamed output and diffs, and decides which permissions to grant.

How does an ACP session start?

Lifecycle per the protocol overview: the client calls initialize; calls authenticate if the agent requires it; then session/new, or an existing session instead: session/load (needs the loadSession capability; the agent replays the conversation history through session/update) or session/resume (needs sessionCapabilities.resume; the agent MUST NOT replay history and returns once the session is ready to continue). Then session/prompt. While working, the agent streams session/update notifications, and the prompt turn ends with a stop reason. A client can end a session with session/close (needs sessionCapabilities.close): the agent MUST cancel ongoing work as if session/cancel had been called, then free the session's resources. The protocol overview page lists session/load and session/set_mode as optional methods; session/resume and session/close appear only on the session-setup page.

Method list for protocol v1 as of 2026-10-11 (a v2 draft exists; the spec is evolving; check the current docs):

How do ACP agents get MCP servers?

The client passes an mcpServers array in session/new, and the session-setup page says "Agents SHOULD connect to all MCP servers specified by the Client." Stdio transport for MCP servers MUST be supported; HTTP and SSE are optional and advertised in agentCapabilities.mcpCapabilities. The docs note SSE is deprecated by the MCP spec and new agents SHOULD support HTTP.

What transports does ACP use?

• stdio: agents SHOULD support it whenever possible.
• Streamable HTTP: marked draft / in discussion in the transports page, so do not treat it as settled.
• Custom transports are allowed (the transports page lists stdio, Streamable HTTP and custom transports as the defined mechanisms).
• The introduction page says remote agents can communicate over HTTP or WebSocket and that full support for remote agents is a work in progress. The transports page does not define a WebSocket transport.

How do tool calls and permissions work?

• Tool call kind: read, edit, delete, move, search, execute, think, fetch, switch_mode, other.
• Tool call status: pending, in_progress, completed, failed.
• Before a sensitive action the agent can call session/request_permission; option kinds are allow_once, allow_always, reject_once, reject_always.

How does ACP relate to MCP, A2A and A2UI? (general context, not from the ACP docs, except the MCP row)

Inference, not spec text: because the editor decides permission answers and which MCP servers are passed in, it is the natural enforcement point for guardrails on a coding agent (see /resources/agent-guardrails).

What was not verified

The launch date, adoption statistics beyond the 2026-10-11 agent count, and whether any particular agent or editor implements every method above were not verified. The Streamable HTTP transport is described as a draft.

See also: /resources/mcp-vs-a2a, /resources/a2a-protocol, /resources/a2ui-protocol, /resources/generative-ui-for-agents, /resources/agent-guardrails, /resources/agentic-payment-protocols

Verified sources

Fetched directly 2026-10-11:

• Introduction: https://agentclientprotocol.com/overview/introduction
• Repository: https://github.com/agentclientprotocol/agent-client-protocol
• Protocol overview: https://agentclientprotocol.com/protocol/overview
• Session setup: https://agentclientprotocol.com/protocol/session-setup
• Transports: https://agentclientprotocol.com/protocol/transports
• Tool calls: https://agentclientprotocol.com/protocol/tool-calls
• Agents: https://agentclientprotocol.com/overview/agents
• Clients: https://agentclientprotocol.com/overview/clients
• Zed ACP page: https://zed.dev/acp

#acp #agent-client-protocol #protocols #coding-agents #editors #json-rpc #mcp #interoperability

Category: Guide