{
  "slug": "agent-client-protocol",
  "title": "Agent Client Protocol (ACP): How Editors Talk to Coding Agents",
  "description": "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.",
  "category": "Guide",
  "tags": [
    "acp",
    "agent-client-protocol",
    "protocols",
    "coding-agents",
    "editors",
    "json-rpc",
    "mcp",
    "interoperability"
  ],
  "updated": "2026-10-11",
  "premium": false,
  "rights": {
    "access": "free",
    "license": "https://changegamer.ai/license.xml",
    "pricing": "https://changegamer.ai/api/pricing.json",
    "payment": "https://changegamer.ai/api/payment.json"
  },
  "canonical": "https://changegamer.ai/resources/agent-client-protocol",
  "markdown": "https://changegamer.ai/resources/agent-client-protocol.md",
  "outline": [
    {
      "depth": 2,
      "text": "Key facts",
      "anchor": "key-facts"
    },
    {
      "depth": 2,
      "text": "What is the Agent Client Protocol?",
      "anchor": "what-is-the-agent-client-protocol"
    },
    {
      "depth": 2,
      "text": "How does an ACP session start?",
      "anchor": "how-does-an-acp-session-start"
    },
    {
      "depth": 2,
      "text": "How do ACP agents get MCP servers?",
      "anchor": "how-do-acp-agents-get-mcp-servers"
    },
    {
      "depth": 2,
      "text": "What transports does ACP use?",
      "anchor": "what-transports-does-acp-use"
    },
    {
      "depth": 2,
      "text": "How do tool calls and permissions work?",
      "anchor": "how-do-tool-calls-and-permissions-work"
    },
    {
      "depth": 2,
      "text": "How does ACP relate to MCP, A2A and A2UI? (general context, not from the ACP docs, except the MCP row)",
      "anchor": "how-does-acp-relate-to-mcp-a2a-and-a2ui-general-context-not-from-the-acp-docs-except-the-mcp-row"
    },
    {
      "depth": 2,
      "text": "What was not verified",
      "anchor": "what-was-not-verified"
    },
    {
      "depth": 2,
      "text": "Verified sources",
      "anchor": "verified-sources"
    }
  ],
  "related": [
    {
      "slug": "mcp-vs-a2a",
      "title": "MCP vs A2A: Two Protocols, Two Roles",
      "description": "Compact comparison of the Model Context Protocol (agent↔tool) and the Agent2Agent Protocol (agent↔agent): purpose, topology, transport, discovery, auth, governance, and when to use each.",
      "url": "https://changegamer.ai/resources/mcp-vs-a2a"
    },
    {
      "slug": "a2a-protocol",
      "title": "A2A Protocol (Agent2Agent): Agent Card, Operations, Task States, Bindings",
      "description": "Wire-level reference for the A2A (Agent2Agent) protocol v1.0: the Agent Card at /.well-known/agent-card.json, the 11 operations, the 8 task states, three protocol bindings, security schemes, version negotiation, and what changed from v0.3.",
      "url": "https://changegamer.ai/resources/a2a-protocol"
    },
    {
      "slug": "building-mcp-servers",
      "title": "Building an MCP Server",
      "description": "Implementation guide for MCP servers: architecture roles, the three server primitives, stdio vs Streamable HTTP transports, official SDKs, server lifecycle, remote-server concerns, testing with MCP Inspector, and publishing to the official registry.",
      "url": "https://changegamer.ai/resources/building-mcp-servers"
    },
    {
      "slug": "mcp-apps-explained",
      "title": "MCP Apps Explained: The Official Interactive-UI Extension for MCP",
      "description": "What MCP Apps (SEP-1865) is: the ui:// resource scheme and sandboxed-iframe/JSON-RPC bridge it defines for MCP tools to return rendered UI instead of plain text, how it relates to the community MCP-UI project and OpenAI's Apps SDK, and which hosts support it.",
      "url": "https://changegamer.ai/resources/mcp-apps-explained"
    }
  ],
  "furtherReading": [
    {
      "slug": "mcp-oauth-implementation",
      "title": "How to Implement OAuth 2.1 for an MCP Server",
      "description": "A wire-level implementation walkthrough for OAuth 2.1 on a remote MCP server: what the discovery documents actually contain, CIMD vs. Dynamic Client Registration in your server code, per-SEP detail from the 2026-07-28 hardening set, and token-validation mechanics.",
      "url": "https://changegamer.ai/articles/mcp-oauth-implementation"
    },
    {
      "slug": "mcp-server-in-production",
      "title": "MCP Authentication and the Production MCP Server Playbook",
      "description": "MCP authentication with OAuth 2.1, plus transport, tool design, versioning, testing, distribution and observability for a production MCP server.",
      "url": "https://changegamer.ai/articles/mcp-server-in-production"
    }
  ],
  "body": "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.\n\n## Key facts\n\n- 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.\n- 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).\n- The repository README states contributions are licensed under Apache-2.0. Official libraries listed there: Kotlin, Java, Python, Rust, TypeScript.\n- 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.\n- 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).\n- zed.dev/acp says ACP was created by Zed and grown by the community, with JetBrains and Zed collaborating on it.\n\n## What is the Agent Client Protocol?\n\nWithout 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.\n\n## How does an ACP session start?\n\nLifecycle 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.\n\nMethod list for protocol v1 as of 2026-10-11 (a v2 draft exists; the spec is evolving; check the current docs):\n\n| Direction | Methods |\n|---|---|\n| Client to agent | `initialize`, `authenticate`, `session/new`, `session/prompt`, `session/load`, `session/resume`, `session/close`, `logout`, `session/set_mode`; notification `session/cancel` |\n| Agent to client | `session/request_permission`, `fs/read_text_file`, `fs/write_text_file`, `terminal/create`, `terminal/output`, `terminal/release`, `terminal/wait_for_exit`, `terminal/kill`, `elicitation/create`; notifications `elicitation/complete`, `session/update` |\n\n## How do ACP agents get MCP servers?\n\nThe 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.\n\n## What transports does ACP use?\n\n- stdio: agents SHOULD support it whenever possible.\n- Streamable HTTP: marked draft / in discussion in the transports page, so do not treat it as settled.\n- Custom transports are allowed (the transports page lists stdio, Streamable HTTP and custom transports as the defined mechanisms).\n- 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.\n\n## How do tool calls and permissions work?\n\n- Tool call `kind`: `read`, `edit`, `delete`, `move`, `search`, `execute`, `think`, `fetch`, `switch_mode`, `other`.\n- Tool call `status`: `pending`, `in_progress`, `completed`, `failed`.\n- Before a sensitive action the agent can call `session/request_permission`; option kinds are `allow_once`, `allow_always`, `reject_once`, `reject_always`.\n\n## How does ACP relate to MCP, A2A and A2UI? (general context, not from the ACP docs, except the MCP row)\n\n| Protocol | Connects | Relation to ACP |\n|---|---|---|\n| ACP | editor/client <-> coding agent | this entry |\n| MCP | agent <-> tools and data | ACP reuses MCP JSON types and forwards MCP servers to the agent |\n| A2A | agent <-> agent | different layer; see /resources/a2a-protocol |\n| A2UI | agent <-> user-facing app UI | different layer; see /resources/a2ui-protocol |\n\nInference, 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).\n\n## What was not verified\n\nThe 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.\n\nSee also: /resources/mcp-vs-a2a, /resources/a2a-protocol, /resources/a2ui-protocol, /resources/generative-ui-for-agents, /resources/agent-guardrails, /resources/agentic-payment-protocols\n\n## Verified sources\n\nFetched directly 2026-10-11:\n\n- Introduction: https://agentclientprotocol.com/overview/introduction\n- Repository: https://github.com/agentclientprotocol/agent-client-protocol\n- Protocol overview: https://agentclientprotocol.com/protocol/overview\n- Session setup: https://agentclientprotocol.com/protocol/session-setup\n- Transports: https://agentclientprotocol.com/protocol/transports\n- Tool calls: https://agentclientprotocol.com/protocol/tool-calls\n- Agents: https://agentclientprotocol.com/overview/agents\n- Clients: https://agentclientprotocol.com/overview/clients\n- Zed ACP page: https://zed.dev/acp",
  "sources": [
    "https://agentclientprotocol.com/overview/introduction",
    "https://github.com/agentclientprotocol/agent-client-protocol",
    "https://agentclientprotocol.com/protocol/overview",
    "https://agentclientprotocol.com/protocol/session-setup",
    "https://agentclientprotocol.com/protocol/transports",
    "https://agentclientprotocol.com/protocol/tool-calls",
    "https://agentclientprotocol.com/overview/agents",
    "https://agentclientprotocol.com/overview/clients",
    "https://zed.dev/acp"
  ]
}