ACP (Agent Client Protocol) is the definitive open standard for connecting AI coding agents to development environments (IDEs). Much like the Language Server Protocol (LSP) standardized autocomplete and diagnostics, ACP provides a unified JSON-RPC interface that allows any AI agent to run natively in compatible editors like Zed and JetBrains without bespoke plugins.
TL;DR: ACP at a Glance
- Current Status: Verified July 2026.
- Key Partners: Zed Industries, JetBrains, Obsidian, Neovim (via plugin).
- Core Benefit: Decouples agents from editors; allows agents to see unsaved file buffers via proxying.
- Ecosystem: 50+ registered agents including Gemini CLI, Claude Code (via adapter), and GitHub Copilot CLI.
What is the Agent Client Protocol (ACP)?
The Agent Client Protocol (ACP) is an open JSON-RPC 2.0 standard that defines how a code editor (the client) communicates with an AI coding agent (the server). Before ACP, a developer wanting to use a new AI agent in their favorite editor faced the "N*M Problem": every agent needed a custom plugin for every IDE.
ACP breaks this cycle. By implementing a single shared contract, an agent author can write their tool once and have it appear natively in the chat panels, diff views, and terminal windows of every ACP-compliant editor.
How it Works: The Subprocess Model
Unlike cloud-heavy protocols, ACP operates primarily over Standard IO (stdin/stdout). The editor launches the agent as a local subprocess. This ensures:
- Security: The trust boundary remains on your local machine.
- Performance: Zero-latency communication for real-time streaming and tool calls.
- Simplicity: No complex network listeners or long-running daemons required.
How Does ACP Compare to MCP?
It is common to confuse ACP with Anthropic’s Model Context Protocol (MCP), but they operate at different layers of the stack. In a modern 2026 AI engineering setup, you don’t choose between them—you use both.
| Feature | Agent Client Protocol (ACP) | Model Context Protocol (MCP) |
|---|---|---|
| Connection | Editor ↔ Agent | Agent ↔ Tools/Data |
| Primary Goal | Driving the UI (chat, diffs, terminals) | Accessing external context (DBs, APIs) |
| Who Drives? | The IDE drives the Agent | The Agent drives the Tools |
The Verdict: MCP gives the agent tools; ACP gives the agent an editor interface. When you start an ACP session, your IDE can even pass MCP server endpoints to the agent, creating a fully integrated development harness. This is a core component of Harness Engineering for reliable autonomous agents.
Why ACP Uses File System Proxying
One of the most critical innovations in ACP is the File System Proxy capability. In traditional CLI-based agents, the agent reads directly from the disk (e.g., using fs.readFile). This creates a "blindness" problem: the agent cannot see the unsaved changes currently sitting in your editor’s buffer.
ACP solves this by allowing the editor to advertise a fileSystem capability. When enabled, the agent sends read_file requests through the protocol to the editor instead of the disk.
- Human Sync: The agent sees exactly what you see on your screen, including unsaved refactors.
- Contextual Awareness: This prevents the agent from overwriting your current work with stale data from the last save point.
This high-fidelity awareness is essential for building high-fidelity feedback loops in AIX Engineering.
The Core ACP Workflow: From Prompt to Diff
A standard ACP session follows a structured JSON-RPC lifecycle:
- Initialize: The client and agent exchange versions and capabilities (e.g., "I support terminal proxying," "I support diff-based editing").
- Session Creation: Every chat thread is assigned a unique
session_id. This allows for scaling agent fleets across multiple machines or projects. - The Prompt Loop: The client sends a
prompt. The agent responds with anagentMessageChunkfor real-time streaming text. - Tool Calls: If the agent needs to edit a file, it sends a
toolCallnotification. The editor renders this in a native UI (like a "proposed change" box). - The Diff: For code modifications, the agent sends an
old_textandnew_textblock. The editor handles the diffing, syntax highlighting, and "Accept/Reject" logic.
What This Means For You
Whether you are a solo developer or managing a team, ACP represents a shift toward Agent Interoperability.
- For Developers: You can now "Bring Your Own Agent." If a new frontier model launches with a superior CLI agent, you can plug it into Zed or JetBrains instantly. You are no longer locked into your IDE vendor's specific AI implementation.
- For Tool Builders: Focus on making your agent smarter, not on maintaining VS Code and IntelliJ plugins. By targeting ACP, you reach the entire ecosystem at once. This approach was pioneered in early agent-native design workflows.
How to Get Started
- Editor Support: Download Zed (native creator) or update JetBrains to the latest 2026 release.
- Registry: Browse the official ACP Registry for agents like Claude Code, Gemini CLI, or Goose.
- Config: Most editors allow you to add custom agents via a simple
acp.jsonconfiguration file, pointing to the agent's executable.
FAQ: Common Questions About ACP
Q: Does VS Code support ACP?
A: As of July 2026, VS Code does not have native ACP support. Microsoft has prioritized MCP for its agentic mode. However, stable community extensions (like vscode-acp) are available to bridge the gap.
Q: Can I use ACP agents over a network? A: While the current stable standard uses Standard IO (Subprocesses), the 2026 roadmap includes remote transport support for agents running on separate servers or in remote dev containers.
Q: Do I need a specific model to use ACP? A: No. ACP is model-agnostic. It is a protocol for the agent program (the code that drives the model), not the model itself. You can run agents powered by GPT-4o, Claude 3.5 Sonnet, or local Llama models.
Q: Is there an official ACP SDK? A: Yes. Official SDKs are maintained for TypeScript, Python, Rust, and Kotlin, making it easy to wrap existing CLI tools in an ACP-compliant shell.
Q: How do I handle authentication in ACP? A: ACP supports several auth methods, including environment variables (passed to the subprocess) and client-provided authentication tokens for managed registry agents.
Discussion
0 comments