The Agent Client Protocol (ACP) is an open effort by Zed Industries to standardize how code editors talk to AI coding agents. If the Language Server Protocol decoupled languages from editors, ACP aims to decouple agents from editors, so any ACP-capable agent can work in any ACP-capable editor.
Under the hood, ACP is a pragmatic, JSON-RPC 2.0 based protocol designed around real workflows like streaming updates, permissioned tool calls, and file access. It is early but already usable, with both Rust and TypeScript libraries, examples, and published schemas.
zed-industries
Organization
The problem and the promise
Today, editors and AI agents are tightly coupled. Each pairing demands bespoke glue, which slows adoption and locks users into whatever integrations a vendor prioritizes. ACP tackles this fragmentation by specifying a small set of cross-cutting behaviors: initialize, authenticate, create or load a session, send a prompt, stream progress, ask for permission, and optionally read/write files. By aligning on these building blocks, editors can ship one integration surface and agents can meet users wherever they work (Introduction (Agent Client Protocol), 2025).
Key features
- JSON-RPC 2.0, bidirectional: Agents and clients can both issue requests and notifications, enabling user prompts, streaming updates, and permission workflows (JSON-RPC Working Group, 2013).
- Typed libraries in Rust and TypeScript: Reference implementations live in rust/ and typescript/; the TS code uses Zod schemas for validation (see typescript/acp.ts).
- Session-centric design: Multiple concurrent sessions per connection, with cancellation and streaming updates; see protocol/overview.
- Permissioned tool calls: A first-class handshake for sensitive operations where the agent asks the client to prompt the user before proceeding (Requesting Permission).
- File system access (opt-in): Simple read/write primitives that the client can advertise and gate, keeping users in control.
- MCP-friendly: ACP intentionally reuses JSON representations where possible so editors can expose MCP servers and agents can connect directly (Model Context Protocol, 2025).
Why I like it
ACP feels practical and it reuses JSON-RPC (so it is transport-agnostic and familiar) and borrows concepts from the Model Context Protocol (MCP) where it makes sense, without overfitting to any single UI.
It does not try to be everything: it focuses on building a first-rate agentic coding UX (diffs, tool call lifecycles, streaming updates) and leaves higher-level orchestration to agents. The repository reads like something you can adopt incrementally: a clear schema (schema/schema.json), TS and Rust libraries, and runnable examples in typescript/examples.
Under the hood
ACP embraces a stdio-over-JSON-RPC model for portability and simplicity. Editors typically spawn agents as subprocesses and communicate via stdin/stdout, which works everywhere from terminal UIs to rich IDEs.
The docs/overview explain the architecture, including how agents stream session/update notifications and how clients can relay or proxy MCP servers (docs/overview/architecture.mdx).
On the code side, the TypeScript library exposes AgentSideConnection and ClientSideConnection with strongly-typed request/response flows and Zod validation. For example, typescript/acp.ts wires method dispatch with exhaustive switches and helpful errors like RequestError.methodNotFound, while typescript/examples/agent.ts demonstrates permissioned tool calls and message streaming.
The Rust crate (crates.io) mirrors the API surface and ships an example agent and client in rust/.
import * as acp from "@zed-industries/agent-client-protocol";
import { Writable, Readable } from "node:stream";
import { WritableStream, ReadableStream } from "node:stream/web";
// Connect a client to an ACP agent subprocess (see typescript/examples/client.ts)
const input = Writable.toWeb(agentProcess.stdin) as WritableStream;
const output = Readable.toWeb(agentProcess.stdout) as ReadableStream;
const conn = new acp.ClientSideConnection((_agent) => new MyClient(), input, output);
await conn.initialize({
protocolVersion: acp.PROTOCOL_VERSION,
clientCapabilities: { fs: { readTextFile: true, writeTextFile: true } },
});
const { sessionId } = await conn.newSession({ cwd: process.cwd(), mcpServers: [] });
const result = await conn.prompt({
sessionId,
prompt: [{ type: "text", text: "Hello agent" }],
});
console.log(result.stopReason);Use cases
ACP’s sweet spot is agentic editing inside editors. Think: refactors that span multiple files, test creation with edits and diffs, or codebase search-and-explain sessions that interleave reading and writing.
Because ACP is decoupled from specific UIs, the same agent can present a consistent workflow across editors. Early support includes Zed and a Neovim integration via CodeCompanion, and Google’s Gemini CLI ships a production integration that speaks ACP to Zed (Google, 2025). If you already run MCP servers for tools and data, ACP gives agents a route to use them directly within an editor session.
Community and contributing
The project is positioned for broad adoption. Changes flow through issues and discussions with deliberate design review; see issues and discussions. The repository’s README and docs site are concise, with concrete examples for both sides of the connection. If you want to extend the protocol, AGENTS.md details the steps across Rust and TypeScript implementations.
Usage and license
ACP is licensed Apache-2.0, which permits use, modification, and distribution with attribution and patent grant (see LICENSE-APACHE). That is a friendly choice for companies and open-source maintainers alike.
About Zed Industries
Zed builds the high-performance, Rust-powered Zed editor and leads ACP’s development. The company’s focus on agentic editing is visible across its product and blog, including the recent “Bring Your Own Agent to Zed” announcement, which highlights ACP’s role in connecting editors and agents (Zed Industries; Sobo, 2025).
Impact and what’s next
Protocols win by being small, useful, and widely implemented. ACP checks the first two boxes already. With libraries in two languages, a clean schema, and a real editor shipping support, it has a credible path to ecosystem uptake.
If you build agents, ACP is an efficient way to reach users across editors. If you build editors, ACP opens your door to a growing ecosystem of agents without per-agent integrations. The strongest near-term opportunities lie in: integrating ACP in more editors; codifying more tool call patterns (test runs, task runners, terminals); and deepening MCP interop so agents can route rich tool use through a consistent interface.
Conclusion
ACP is a timely, focused protocol that makes agentic editing portable. It brings clarity to the handoff between humans, editors, and agents without overreaching. Start by reading the Introduction, skim the Protocol Overview, then open typescript/examples and run the demo client/agent. Whether you are shipping an agent or an editor, ACP is worth adopting now.
Agent Client Protocol: Making Agentic Editing Portable