Using AI coding agents inside your IDE works but it's rarely as seamless as it should be. Some features of your favorite agent are missing in the plugin of your IDE compared to another (you can see the difference between Claude Code plugin in VSCode and IntelliJ). A new agent gets a lot of buzz, but there's no support for your editor yet. You make it work, but there's always friction somewhere.
On the other side, agent developers face a different headache: they need to integrate into every IDE on the market. IntelliJ, VS Code, Zed, Neovim, and counting. Each one has its own API, its own extension format, its own quirks. And every time they ship an update, every plugin needs to follow — which it often doesn't or with a different experience.
This is the exact same problem the software industry solved once before, with the Language Server Protocol. And the same solution is now emerging for AI agents: the Agent Client Protocol (ACP).
This article covers what ACP is, how it works under the hood, how it relates to MCP, and how you can use it today.
The problem ACP solves
Before LSP, every editor needed custom plugins for every programming language — autocompletion, go-to-definition, linting. It was an N×M integration problem. LSP turned it into N+M: language servers implement one protocol, editors support one protocol, everything just works.
AI agents face the same N×M challenge. Every new agent needs a custom integration for every editor it wants to support. Every editor needs a custom integration for every agent it wants to offer. With 30+ agents and a dozen editors, that's hundreds of individual integrations — each one fragile, each one lagging behind the agent's latest release.
ACP collapses this the same way LSP did. Agents implement one protocol. Editors adopt one protocol. A new agent immediately works in every compatible editor. A new editor immediately supports every compatible agent. No custom work, no vendor lock-in.
Who's behind it
ACP was created by Zed Industries (the team behind the Zed editor) and launched in August 2025 with Google's Gemini CLI as the first reference implementation. In October 2025, JetBrains announced they would co-develop the protocol and bring ACP support to their entire IDE lineup. In January 2026, they jointly launched the ACP Agent Registry — a curated directory of agents installable in one click from any compatible editor.
The protocol is open source under the Apache 2.0 license, hosted at agentclientprotocol.com.
The ecosystem has grown fast. Over 30 agents have adopted ACP, including Claude Code, Codex CLI, Gemini CLI, Cursor (which joined the registry in March 2026), Cline, Junie, GitHub Copilot, Kiro CLI, Kimi CLI, OpenCode, Augment Code, and more. On the editor side, Zed has native support, JetBrains IDEs support it from 2025.3 with full registry integration in 2026.1, and community plugins exist for VS Code, Neovim and Obsidian.
How ACP works under the hood
The technical design is deliberately simple. ACP uses JSON-RPC 2.0 over stdio — when you activate an agent, your editor spawns it as a subprocess and communicates through stdin/stdout pipes. No network configuration, no ports, no complex setup.
The conversation follows a predictable sequence:
1. Initialize — The editor sends an initialize request declaring its capabilities (filesystem access, terminal, etc.). The agent responds with its own capabilities (image support, session loading, etc.).
{
"jsonrpc": "2.0",
"id": 0,
"method": "initialize",
"params": {
"protocolVersion": 1,
"clientCapabilities": {
"fs": { "readTextFile": true, "writeTextFile": true },
"terminal": true
},
"clientInfo": { "name": "intellij-idea", "version": "2026.1" }
}
}
2. New session — The editor creates a session, passing the working directory and available MCP servers.
{
"jsonrpc": "2.0",
"id": 1,
"method": "session/new",
"params": {
"cwd": "/home/user/my-project",
"mcpServers": []
}
}
3. Prompt — The user sends a message. The agent streams back responses in real-time via JSON-RPC notifications — the editor can display progress token by token.
{
"jsonrpc": "2.0",
"id": 2,
"method": "session/prompt",
"params": {
"sessionId": "sess_abc123",
"content": [{ "type": "text", "text": "Refactor this controller" }]
}
}
The communication is bidirectional: the editor sends prompts to the agent, but the agent can also request things back — reading a file, writing a file, running a terminal command. The editor mediates all access, keeping the user in control of what the agent can do.
ACP reuses data types from MCP wherever possible, so structures like text content, diffs, and tool results follow established JSON schemas. Human-readable text defaults to Markdown.
ACP vs MCP: complementary, not competing
This is the question everyone asks. The short answer: MCP connects agents to tools. ACP connects agents to editors. They operate at different layers of the stack and are designed to work together.
MCP (Model Context Protocol) standardizes how agents access external tools and data sources — databases, APIs, file systems, web search. It answers the question: what can the agent access?
ACP (Agent Client Protocol) standardizes how agents integrate into development environments — editors, IDEs, notebooks. It answers the question: where does the agent live in your workflow?
In practice, they compose naturally. When an ACP session starts, the editor can pass its configured MCP servers to the agent. The agent then uses MCP to access tools while communicating with the editor through ACP:
Editor ←— ACP (JSON-RPC/stdio) —→ Agent ←— MCP (JSON-RPC) —→ Tools & Data
A concrete example: you're in IntelliJ with Gemini CLI connected via ACP. You ask it to analyze your database schema. Gemini uses MCP to query a connected PostgreSQL server, gets the schema, and sends the analysis back to IntelliJ through ACP — rendered inline in the AI chat panel. With IntelliJ 2026.1, agents can even access your IDE's configured data sources natively, making this kind of workflow seamless.
Don't confuse with IBM's ACP. There's a separate protocol also called ACP — the Agent Communication Protocol — created by IBM's BeeAI team for agent-to-agent communication. It has since merged with Google's A2A protocol under the Linux Foundation. It's a completely different thing solving a different problem (agents talking to each other, not agents talking to editors).
Using ACP in JetBrains IDEs
ACP support landed in JetBrains IDEs with version 2025.3 and matured significantly with 2026.1, which brought the built-in ACP Registry, one-click agent installation, and expanded agent capabilities like database access and Git worktree support. It works across the entire lineup — IntelliJ IDEA, PyCharm, WebStorm, GoLand, and the rest. No JetBrains AI subscription is required.
From the ACP Registry (recommended)
This is the easiest path and the one JetBrains is pushing forward:
- Open the AI Chat tool window
- Click the chat mode selector and choose Install From ACP Registry (or go to Settings | Tools | AI Assistant | Agents)
- Browse the available agents — Cursor, Claude Agent, Codex, Gemini CLI, Kimi CLI, Augment Code, and many more
- Click Install — the IDE downloads everything needed, including runtimes if required
- Select the agent from the dropdown in AI Chat and start prompting
That's it. The agent runs as a local subprocess. The registry handles updates automatically.
On the Agents settings page, you can also configure MCP exposure:
- Pass custom MCP servers — exposes your configured MCP servers to installed agents
- Pass IntelliJ MCP server — gives agents access to the IDE's built-in MCP server (project structure, open files, data sources)
Manual configuration
For agents not in the registry or custom setups, you can still edit ~/.jetbrains/acp.json directly:
{
"default_mcp_settings": {
"use_idea_mcp": true,
"use_custom_mcp": true
},
"agent_servers": {
"Gemini CLI": {
"command": "/path/to/gemini",
"args": ["--experimental-acp"],
"env": {}
}
}
}
Restart your IDE, and the agent appears in the AI Chat selector.
What's new in 2026.1 specifically
The 2026.1 release made ACP a first-class citizen in JetBrains IDEs. Beyond the registry, a few features stand out:
- Database access for agents — Codex, Claude Agent, and other ACP agents can query and modify your IDE's configured data sources natively.
- Git worktrees — Work in parallel branches and hand one off to an agent while you keep coding in another. A natural fit for agent-driven workflows.
- Cursor in the registry — Cursor joined the ACP Registry in March 2026, bringing its agentic workflows directly into JetBrains IDEs.
Using ACP in Zed
Zed has native ACP support and is where the protocol was born. The quickest way to get started: open the agent panel (Cmd+? / Ctrl+?), hit the + button, and pick an agent — Gemini CLI, Claude Agent, and Codex are available out of the box.
For additional agents, use the ACP Registry (zed: acp registry in the command palette) or add them manually in your settings:
{
"agent_servers": {
"My Custom Agent": {
"type": "custom",
"command": "/path/to/agent",
"args": ["acp"]
}
}
}
What this changes in practice
The practical impact is bigger than it might seem at first:
For developers, you're no longer choosing between "the IDE I love" and "the agent I want." Use PyCharm with Claude Code. Use IntelliJ with Cursor. Use Zed with Codex. Switch agents for different tasks without switching editors.
For agent developers, you implement ACP once and reach users across Zed, JetBrains, Neovim, VS Code, and every future client that adopts the protocol. No more maintaining editor-specific plugins that break with every release.
For the ecosystem, it creates healthy competition. Agents compete on intelligence and capability, not on which editors they happen to support. Editors compete on UX and developer experience, not on which agents they've managed to integrate.
Getting started
- Make sure your IDE supports ACP (JetBrains 2026.1+, Zed, or a community plugin for VS Code/Neovim)
- Open the ACP Registry from your IDE and install an agent in one click
- Or install manually from the agents list and configure
acp.json - Open the AI Chat panel and start using it
The full protocol specification and SDK are at agentclientprotocol.com. The JetBrains documentation covers IDE-specific setup in detail.
ACP is still young — launched mid-2025, with JetBrains joining in October and the registry going live in January 2026. But with 30+ agents, Cursor on board, and the two biggest IDE ecosystems backing it, the trajectory is clear. This is the LSP moment for AI agents.
If you found this helpful, you can buy me a coffee ☕.
Top comments (0)