From Autocomplete to Autonomous: How ACP Is Powering AI Coding Agents in Modern IDEs

AI Coding Agents Meet Your IDE: The Agent Client Protocol (ACP)

🟧 Not a Medium member? Read this article for free.

Over the last few months, I have written extensively about **AI coding and agents, from AI-integrated IDEs such as [VS Code Copilot](https://medium.com/vibecodingpub/6-new-ai-coding-features-in-vs-code-and-copilot-ee0d4cb40a67?sk=a33165acc7e21419b25708816bd1064d) and [Windsurf](https://medium.com/vibecodingpub/implementing-a-spring-boot-service-using-windsurf-and-claude-da1843703617?sk=0e20ccfbd278b93ad9c79e6c83041470) to other agentic coding tools such as [Claude Code](https://medium.com/vibecodingpub/migrating-a-spring-boot-2-x-project-using-claude-code-4a8dbe13125c?sk=90a9cac2020bde243090b8a76c4b2771), [Gemini CLI](https://medium.com/vibecodingpub/gemini-cli-yet-another-terminal-based-ai-assisted-ab3fad1d762a?sk=abf245b02558552b553960e2de4687d8), [JetBrains Junie](https://medium.com/vibecodingpub/can-junie-be-a-real-competitor-for-cursor-windsurf-and-vs-code-copilot-a6202660f477?sk=29ce934c5ecc63b12441eb45c27250b6), or [Warp 2](https://medium.com/vibecodingpub/what-makes-warp-2-0-different-than-other-agentic-systems-3a3f53479bdb?sk=4d596b69ced965d3182d8908438f8cf5)**.

[embed]🤖 AI Coding This list contains my articles related to AI-integrated IDEs, Agentic coding tool, AI-assisted coding, and more.zarinfam.medium.com

In this article, we explore the **Agent Client Protocol (ACP), a crucial component for the future of AI agent development. We will see how ACP can enable AI agents to work seamlessly across different IDEs and editors**.

Agent Client Protocol architecture

· What are AI coding agents? ∘ Why are AI coding agents important for code editors? · What is ACP, and what role does it play? ∘ The Agent Client Protocol (ACP) ∘ Agent Client Protocol architecture ∘ ACP Design Principles ∘ How does the Agent Client Protocol work? · Which IDEs support Agent Client Protocol (ACP)? · Which AI Coding Agents support Agent Client Protocol (ACP)? · Final thoughts

What are AI coding agents?

**AI coding agents are advanced programming assistants powered by generative AI (LLMs) that can read, reason** about, and modify code on behalf of us.

Unlike simple traditional autocomplete or snippet tools, these agents can perform autonomous, multi-step tasks

For example, refactoring functions, generating entire modules from a specification, or fixing bugs based on tests. In other words, they act like “virtual pair programmers” that you interact with by prompts or commands.

Popular examples include **Google’s Gemini CLI, [Anthropic’s Claude Code](https://medium.com/vibecodingpub/migrating-a-spring-boot-2-x-project-using-claude-code-4a8dbe13125c?sk=90a9cac2020bde243090b8a76c4b2771), [OpenAI Codex](https://medium.com/vibecodingpub/openai-enters-the-agentic-coding-tools-game-e3c795869357?sk=878b3009afbcf3121783afe7277ba27e), [JetBrains Junie](https://medium.com/vibecodingpub/can-junie-be-a-real-competitor-for-cursor-windsurf-and-vs-code-copilot-a6202660f477?sk=29ce934c5ecc63b12441eb45c27250b6), and [GitHub Copilot](https://medium.com/vibecodingpub/6-new-ai-coding-features-in-vs-code-and-copilot-ee0d4cb40a67?sk=a33165acc7e21419b25708816bd1064d)**. Typically, these agents run as subprocesses or services and communicate through text I/O, which means integrating them into an IDE requires custom glue code for each tool.

Why are AI coding agents important for code editors?

Integrating these agents into code editors and IDEs offers significant productivity improvements.

Instead of copying code back and forth between separate chat windows or terminals, we can ask the agent to operate within our project context.

This enables use cases such as generating code with full access to the project files, automatically applying syntax-highlighted diffs, running tests on suggested patches, and even asking the agent to explain unfamiliar code.

However, today, nearly every editor-agent combination requires a custom integration, creating a lock-in.

What is ACP, and what role does it play?

Similar to the **Language Server Protocol**, which unbundles languages from IDEs,

The goal of ACP is to allow us to switch between multiple agents without requiring you to switch our IDE or editor.

In practice, ACP means interoperability, allowing any ACP-compatible IDE to communicate with any ACP agent, so developers aren’t forced to use a single editor for a specific AI service. This avoids vendor lock-in.

For example, being tied to VS Code and GitHub Copilot or being tied to JetBrains IDEs for using the Junie agent will be gone, and developers will be allowed to mix and match tools.

Integrating agents via ACP can make AI assistance feel like a natural, secure part of the IDE, rather than a bolt-on hack.

The Agent Client Protocol (ACP)

The **Agent Client Protocol (ACP) is an open, editor-agnostic standard* (Apache-licensed) that defines how code editors (the client) and AI coding agents (the server*) communicate.

We can consider ACP as the LSP for AI agents, it provides a standardized JSON-RPC interface so any compatible editor can communicate with any compatible agent.

The protocol was introduced in 2025 when Zed Industries (the company behind the **Zed code editor) partnered with Google to develop “[Bring Your Own Agent](https://zed.dev/blog/bring-your-own-agent-to-zed)**” support: Google’s Gemini CLI became the first reference implementation.

ACP’s role is to decouple the AI assistant from the IDE. Any editor that implements the ACP client can spawn or connect to an external agent that understands ACP messages. This allows developers to choose their preferred editor and AI tool independently.

Image from the ACP website

Agent Client Protocol architecture

Under the hood, ACP is built on JSON-RPC 2.0 over standard streams. When an ACP session starts, the editor spawns the agent process (or connects to it) and all communication goes via stdin/stdout pipes, just like a language server. The agent and editor exchange bidirectional JSON messages. The design is optimized for rich, interactive code editing:

• Streaming JSON-RPC: The editor can send a request (e.g. “make X async”), and the agent replies via a stream of JSON-RPC notifications as it “thinks,” sending partial outputs token-by-token. This keeps the UI responsive by showing live progress.
• Bidirectional calls: Agents can also call the editor back. For example, if the agent needs to write a file or run a test, it issues a JSON-RPC request for permission.
• MCP-friendly data model: ACP reuses types from the Model Context Protocol (MCP) where possible, to avoid reinventing schemas. This means things like file contents, code diffs, or tool execution results follow an established JSON schema. All human text is sent as Markdown, allowing editors to render it richly. Moreover, ACP sessions can include references to external MCP servers (for tools). The editor passes the configured MCP endpoints to the agent, allowing it, for instance, to run tests or query databases via those servers.

ACP Design Principles

ACP spec emphasizes three key goals:

1. Interoperability, a great user experience, and a trusted local model. For interoperability, any editor + any agent should work without custom plug-ins.
2. UX, ACP provides multi-buffer diffs and live highlights so developers can “follow the agent around the codebase” as it works.
3. Trust, agents run under the user's privilege and must obtain explicit approval for sensitive actions.

Overall, the architecture is quite pragmatic:

A simple JSON-RPC protocol supporting multiple simultaneous sessions, streaming updates, and optional file read/write operations.

The official spec even includes typed libraries in TypeScript and Rust to make adoption easier.

How does the Agent Client Protocol work?

ACP workflows follow a defined client-server message pattern. In short, the editor (client) initiates communication and then starts a “session” where each user prompt and agent response is one turn. The steps are:

1. Initialize and authenticate: The editor sends a JSON-RPC initialize request to the agent to establish the connection, followed by an authentication step if credentials are needed.

2. Start a session: The editor starts a new conversation by calling session/new or session/load to restore a previous chat. This returns a session ID or context that will be used for future prompts.

3. Prompt turn: Each time the developer gives the agent an instruction, the editor sends a session/prompt request with the user’s message and current context. The agent then begins processing. As it works, it streams back session/update notifications to the editor with partial results (e.g., lines of code or explanation). These updates enable the IDE to display live progress (similar to a streaming chat or typing effect).

4. Handling permissions and files: The agent may need to read or write files, run tests, or call external tools. In ACP, these actions happen via defined methods: for example, the agent can send an fs/read_text_file or fs/write_text_file request, or a session/request_permission notification if it needs user approval. The editor’s client intercepts these calls and either returns the requested data or prompts the user for permission. Only once the editor grants permission does the agent proceed. This ensures the editor controls any sensitive operations.

5. Finishing the turn: Once the agent has finished generating a response, it sends a final result to the original session/prompt call, including a stop reason. The turn is then complete, and the IDE can show the final changes (often as a diff or preview).

6. Cancellation: The developer can cancel a request at any time. If they do, the editor sends a session/cancel notification to the agent, which stops work.

These steps are the core lifecycle described in the spec. Because ACP follows standard JSON-RPC rules, all methods follow the usual request-response pattern (with a result or an error), and notifications never return a response.

Importantly, all file paths in ACP are absolute, and line numbers follow a 1-based convention.

In practice, developers don’t need to write any ACP code themselves, editor plugins or agent binaries handle this messaging automatically, so using an ACP agent can feel as simple as selecting it from a menu.

Which IDEs support Agent Client Protocol (ACP)?

As of late 2025, ACP support is just beginning to appear in IDEs:

· Zed Editor: Zed Industries (the company behind ACP) added a “**Bring Your Own Agent” feature in August 2025. Zed natively supports ACP. It runs its own internal agent on ACP and can connect to external agents, such as [Google’s Gemini CLI](https://medium.com/vibecodingpub/gemini-cli-yet-another-terminal-based-ai-assisted-ab3fad1d762a?sk=abf245b02558552b553960e2de4687d8). In fact, the initial reference implementation of ACP was the Gemini CLI integration in Zed. Zed has even released beta support for [Anthropic’s Claude Code](https://medium.com/vibecodingpub/migrating-a-spring-boot-2-x-project-using-claude-code-4a8dbe13125c?sk=90a9cac2020bde243090b8a76c4b2771)** via ACP. In short, Zed is currently the most mature ACP-enabled IDE.

· Neovim (with Code Companion): The community quickly added ACP to Neovim through the “**CodeCompanion.nvim**” plugin. Neovim’s code-completion plugin is also updated so that when you use a CLI-based agent (Gemini CLI, Claude, etc.), the plugin speaks ACP under the hood.

· Visual Studio Code: As of now, there is no official built-in support for ACP in VS Code. At the time of writing, that issue is under discussion, but no release includes ACP.

· JetBrains IDEs (coming soon / in progress): JetBrains is actively integrating ACP across its IDE ecosystem, so many of its major tools will support it soon or are in preview or beta.

Which AI Coding Agents support Agent Client Protocol (ACP)?

As we learn about the **Agent Client Protocol (ACP), to complete the chain alongside IDEs, the AI Coding Agents** should also support ACP, enabling integration with any ACP-compatible IDE or editor.

According to the Agent Client Protocol (ACP) official website, there are many AI Coding Agents that support or will support ACP and can be used with an ACP Client:

• Gemini CLI
• Claude Code
• Codex CLI
• JetBrains Junie (coming soon)
• and more

Final thoughts

**ACP is an early but promising protocol that could standardize how AI agents integrate with IDEs, similar to how LSP standardized language tooling. By enabling a portable** ecosystem of specialized agents that can connect to any editor, ACP could let us swap in testing, optimization, or analysis agents on demand, without being tied to a specific IDE.

The spec is open source and already includes tooling, and as more AI models expose agent-like CLIs, the pressure to support them in editors will increase. If major IDEs like VS Code or JetBrains adopt ACP, the entire AI workflow may move directly into the IDE, where prompts, context, syntax checks, and permissions are handled seamlessly. In that future, we might work with AI co-pilots as naturally as with colleagues, with potentially large productivity gains as long as these protocols keep integrations secure and reliable.

🌟 This list contains my articles related to AI-integrated IDEs, Agentic coding tool, AI-assisted coding, and more:

[embed]List: 🤖 AI Coding | Curated by Saeed Zarinfam | Medium 🤖 AI Coding · This list contains my articles related to AI-integrated IDEs, Agentic coding tool, AI-assisted coding…zarinfam.medium.com

🙏 Thanks for reading. You can connect with me on:

**🖊️ Medium | [🐦 Twitter](https://twitter.com/zarinfam) | [📺 YouTube](https://www.youtube.com/@saeedzf)**