Agent Client Protocol: How Coding Agents Connect to Editors

You can change your coding agent without changing your editor, provided both speak the Agent Client Protocol (ACP). Google's Android Studio Rabbit 2 release makes that choice practical for Android developers: its October announcement names over 40 coding agents, with agent selection inside the IDE. The useful change is keeping your development environment while choosing the agent that does the work.

Google's count comes from its 28 October 2026 Android Studio announcement. Support and setup details below were verified against the protocol site and editor documentation on 3 November 2026. This is a documentation-based guide, not a hands-on agent benchmark.

What Agent Client Protocol Changes

ACP gives editors and coding agents a common interface for prompts, progress, permissions and results. An agent is the program that uses a model, tools and a work loop to carry out a task. Your editor, or integrated development environment (IDE), is where you inspect code, review changes and interact with that program.

The useful analogy is the Language Server Protocol (LSP), which standardized the connection between editors and language servers. A language server supplies language-specific intelligence, such as diagnostics. ACP applies the same separation to coding agents: the editor implements the client connection, and an agent implements ACP directly or through an adapter. Both sides must be compatible. ACP's introduction describes this as removing the need for a custom integration for every pairing.

For a developer alternating between Anthropic's Claude Code, OpenAI's Codex and Google's Gemini CLI, the payoff is a stable place to work. You can evaluate another agent without treating the editor itself as part of the migration. Their ACP integration paths still differ, as the support list below shows.

Who Started ACP?

Zed Industries created ACP, working with Google to make Gemini CLI the initial reference implementation. Zed announced that collaboration on 27 August 2025. JetBrains subsequently joined the effort; its current ACP page describes the protocol as developed openly by JetBrains and Zed. Google is an early implementation partner and an adopter through Android Studio. Zed's launch post and JetBrains' ACP page establish those different roles.

That distinction matters when assessing support. Creating the protocol, maintaining an adapter and shipping an editor client are separate contributions.

Which Editors and Agents Support ACP?

Zed, JetBrains IDEs and Android Studio provide documented routes to ACP agents. Other editors use plugins or extensions, so check the integration you will actually install. A directory entry is evidence of an integration, not a promise that every feature behaves identically.

The plugin names above follow the ACP clients directory. Zed, JetBrains and Android Studio details come from their own documentation below. This is a selection relevant to coding workflows, not an exhaustive list of ACP clients.

Zed: External Agents Have Their Own Configuration

Zed puts ACP agents in its Agent Panel and Threads Sidebar. Its current documentation names Claude, Codex, OpenCode, Copilot, Cursor and Pi among common external agents, and also provides Gemini CLI setup guidance. The primary installation route is the ACP Registry. Zed's External Agents documentation explains both installation and configuration ownership.

The practical limit is configuration inheritance. Zed Agent profiles and Zed Skills do not automatically become the external agent's settings. Record the agent's own instructions, credentials and tools when documenting your team's setup.

JetBrains: Check the Organization and Environment

JetBrains AI Assistant exposes ACP agents through AI Chat. You can install an agent from Settings > Tools > AI Assistant > Agents, or add a custom agent using acp.json. Its documentation also says ACP agents are currently unsupported in Windows Subsystem for Linux (WSL), and administrators can limit registry entries or custom agents. JetBrains' ACP documentation is the authority for those constraints.

For an engineering lead, this means checking the workstation environment before recommending the integration. A working setup on a colleague's laptop does not establish that your managed WSL workflow is supported.

Agents: Native Support and Adapters Are Different

The ACP agents directory names the relevant integrations precisely:

• Claude Agent is listed through Zed's SDK adapter. This is the directory's name for the Claude integration, rather than a claim that the Claude Code CLI itself natively speaks ACP.
• Codex CLI is listed through ACP's adapter. Include that adapter when tracking the components your editor launches.
• Gemini CLI is listed as an implementing agent without an adapter qualifier.
• GitHub Copilot is explicitly marked public preview on that page.

The same page also lists Augment Code, Cline, Cursor, Docker's cagent, Factory Droid, Goose, Hermes Agent, Junie by JetBrains, Kimi CLI, Kiro CLI, Mistral Vibe, OpenCode, OpenHands and Qwen Code. Pi is listed through a pi-acp adapter. These are selected entries using the directory's names; the linked directory carries the full list.

Do not turn that directory into a universal editor compatibility score. Your usable combination depends on the agent, its adapter if required, your editor integration and the capabilities they negotiate.

What Android Studio's Bring Your Own Agent Means

Android Studio lets you choose the coding agent while retaining its Android development tools. Google's stable-release announcement names Claude Agent, Codex, Junie and Google Antigravity, and says agents can access the Android Emulator, build systems, Logcat and Android skills. Logcat is Android's application and system log viewer. Google's Rabbit 2 announcement documents that tool access.

For an Android developer, consider a crash investigation: you want the agent working alongside the project's build and diagnostic tools, while you retain the familiar place to inspect the fix. BYOA makes the agent choice separable from that workspace. Whether the chosen agent diagnoses the crash well remains an evaluation question.

For an engineering lead, the consequence is a more useful pilot. Keep the repository, task and review process consistent, then compare approved agents within that environment. Evaluate the resulting patch, the commands requested and the evidence behind the answer. A successful connection alone is not a successful rollout.

Preview at Launch, Stable Now

Google introduced BYOA in preview on 24 September 2026, starting with Android Studio Rabbit 2 Canary. On 28 October 2026, it announced Rabbit 2 as stable, including BYOA. The newer announcement supersedes the launch post's preview status. Preview announcement, stable announcement.

Keep preview labels attached to the specific component that carries them. Android Studio's stable release does not remove another agent's public-preview label or guarantee an adapter's feature parity.

How an ACP Session Works

The editor starts the agent and exchanges structured messages with it. In the local transport, the editor launches a subprocess: another program running under the operating system. The connection uses JSON-RPC 2.0, a format for requests, responses and notifications, over stdio, the process's standard input and output streams. This is structured communication rather than reading a terminal's rendered text. Protocol overview, transport specification.

The session follows a clear sequence:

1. Start and negotiate. The editor launches the agent or adapter and sends initialize. The two sides exchange protocol versions and capabilities.
2. Authenticate when required. Complete the authentication method the agent advertises. A successful editor connection does not supply an agent account.
3. Open the conversation. The editor sends session/new with the working directory and any MCP servers it is providing. The agent returns a session identifier.
4. Send work and receive progress. The editor sends session/prompt; the agent reports messages and tool activity through session/update notifications.
5. Handle requested actions. When the agent requests permission, the editor presents the available choices and sends the decision back. The turn eventually finishes with a response describing why it stopped.

These are the documented message flow and session-creation rules. A session is the agent's conversation with its own context and state, not a universal conversation file shared by every vendor.

File Edits and Terminal Commands

File and terminal access are negotiated capabilities. When supported, an agent can use fs/read_text_file to read through the editor, including unsaved changes, and fs/write_text_file to write through it. That matters when the buffer on your screen differs from the file saved on disk. ACP filesystem specification.

For commands, terminal/create asks the client to start a process. Related methods retrieve output, wait for completion, stop the command and release the terminal. An agent must check that the client advertised terminal support before using these methods. ACP terminal specification.

An agent can also report edits as diffs and tool progress through ACP while performing its own operations. Seeing activity in the editor does not mean every operation was executed by the editor. Tool-call specification.

ACP vs MCP: Different Connections

ACP connects your editor to the agent; Model Context Protocol (MCP) connects an AI application or agent to tools and data. They can work together in the same session. This comparison follows the ACP session specification and MCP introduction.

When a tool is missing, inspect the tool connection as well as the editor connection. For example, JetBrains has separate settings for passing custom MCP servers and its integrated IntelliJ MCP server to agents. ACP support alone does not switch on every tool. JetBrains' registry settings document those controls.

If you are designing the underlying service boundary, MCP vs API addresses a different decision: how to expose application functionality. If you are building an application around coding agents, the Vercel AI SDK ACP adapter explainer covers that integration layer.

Connect Claude Agent to Android Studio

Use Android Studio's agent selector and authenticate with the agent provider. Google's current onboarding route is the agent window or Settings > Tools > AI > Agents. The launch instructions specify signing in or supplying an API key, with supported account plans determined by the provider. Current onboarding, authentication instructions.

1. 1

   Use a release with BYOA

   Use Android Studio Rabbit 2 stable or a later release whose documentation includes BYOA. The original Canary-only instruction belongs to the preview launch.

2. 2

   Select Claude Agent

   Open the agent window and select Claude Agent. You can also choose agents through Settings > Tools > AI > Agents.

3. 3

   Authenticate for that agent

   Follow the agent's sign-in flow or supply an API key when offered. Use the account and access method approved for your project. Connecting another agent requires that agent's own authentication and entitlement.

4. 4

   Submit a bounded first prompt

   Google's setup ends with submitting a prompt. A useful first task is: “Explain how this project is built and identify the relevant test task. Do not change files.” This prompt is a suggested starting point, not a vendor test result.

5. 5

   Check the workflow before expanding it

   Next, request a small, reviewable change on a working branch. Inspect the proposed edit, permission choices and any requested command. Confirm that you can understand the result before assigning a larger task. This is rollout advice beyond the vendor's connection steps.

If authentication fails, resolve the selected agent's account or key configuration. If the agent connects but cannot use a tool, inspect that integration's exposed capabilities. These are different failure points, so record them separately in your setup notes.

The Limits That Matter for a Team

Standardize the connection, then verify each agent's behavior. The protocol removes integration repetition without making agents interchangeable in every operational detail.

Authentication stays with each agent. Plan for a separate sign-in or API-key arrangement for every selected provider. Existing credentials may be reused by an implementation, but ACP is not a shared account or quota pool. Zed, for example, documents external agents' own authentication and provider relationships. Zed configuration boundaries.

Session recovery is conditional. The protocol's session/load operation requires the agent's loadSession capability. That supports loading an existing session where implemented; it does not establish that a different vendor can inherit the original agent's private state. Before promising frictionless switching, check the exact history behavior your combination supports. Session-loading specification.

Remote support needs a specific implementation check. The current transport page defines stdio and says a Streamable HTTP transport is being specified. Custom transports are permitted. Do not assume that a working local integration automatically works against a remote agent endpoint. ACP transport specification.

Permission Requests Are Not a Sandbox

ACP gives permission decisions a message format; it does not enforce an operating-system boundary. The spec says the agent runs with its process permissions, permission requests are advisory, and the agent is responsible for honoring decisions. The client separately executes the filesystem and terminal methods requested through its own capabilities. ACP security considerations.

A request can offer one-time or remembered approval and rejection choices. The agent owns the scope and persistence of remembered decisions. Read the offered option before assuming “always” means only the current command or directory. Permission-option semantics.

For a platform operator, verify the agent binary, execution environment and permission policy alongside the editor setup. An approval dialog is useful visibility, but its presence alone does not establish containment.

What Is Overhyped, and Who Should Act?

The credible benefit is less coupling between editor and agent. ACP support is not evidence that an agent writes better code, that its configuration transfers from another agent, or that every pairing exposes the same workflow. Evaluate those outcomes directly.

Developers who already switch agents should act now. Try a supported agent in the editor you already use. The decisive test is whether the edit review, command visibility and context handling help you finish a representative task.

Engineering leads should pilot before standardizing. Keep the task and acceptance criteria consistent across agents. Record authentication, supported tools, session recovery and permission behavior. Choose on the resulting work and controllability, not the size of a registry.

Platform operators should wait when a required environment is unsupported. JetBrains' documented WSL limitation is a concrete example. A remote workflow dependent on transport behavior that has not been established is another reason to validate the combination before rollout.

A developer happy with a terminal workflow is largely unaffected. There is no reason to change interfaces solely because a protocol exists. If the unresolved question is which agent handles your work better, use the Codex vs Claude Code comparison to frame that choice, then evaluate it on your repository.

Frequently Asked Questions

What is agent client protocol?

Agent Client Protocol is the common interface between a coding agent and an editor or other client. It lets compatible implementations exchange prompts, progress and actions without a separate bespoke integration for each pairing.

What's the difference between ACP and MCP?

ACP handles the editor-to-agent connection. MCP connects an AI application or agent to external tools and data. An ACP session can provide MCP server configurations, so both protocols can participate in the same workflow.

What is A2A vs MCP?

Agent2Agent (A2A) standardizes communication between independent agents. MCP connects AI applications to external capabilities and data. A2A addresses agent collaboration, while this article's ACP addresses the editor connection. See the A2A project's explanation.

Does Claude Code support agent client protocol?

The precise directory entry is Claude Agent through Zed's SDK adapter. Use the supported integration your editor documents; do not interpret that entry as native ACP support in every Claude Code executable. Zed documents Claude Agent as an external agent with its own authentication.

Is Claude Code still the best coding agent?

ACP support cannot answer that. Compare agents on your repository using the same task, review criteria and allowed tools. Prefer the agent whose changes you can validate and whose workflow fits the work you repeatedly perform.

Who developed the agent client protocol?

Zed created ACP and partnered with Google on Gemini CLI as its initial reference implementation. JetBrains joined the effort, and its current documentation describes ACP as developed openly by JetBrains and Zed.

What is the difference between agent client protocol and agent communication protocol?

They are different projects sharing an acronym. Agent Client Protocol connects editors and coding agents. IBM's Agent Communication Protocol addressed agent-to-agent communication; IBM Research now says it is part of A2A.

How does ACP work?

For a local session, the editor starts the agent as a subprocess and communicates through JSON-RPC over stdio. They negotiate capabilities, complete any required authentication, open a session and exchange prompts, updates and permission decisions.

What is ACP in Agentic AI?

In an editor integration, ACP usually refers to Agent Client Protocol. Spell out the name when reading an architecture or choosing a library: the Agent Communication Protocol acronym refers to a different project.

Your Next Working Session

Keep your editor, choose an approved ACP agent and start with a small repository task whose result you can review. Write down the agent and adapter used, its authentication method, available tools and permission behavior. Expand the pilot only after the full working loop is clear, including what happens when you deny an action.

For practical guides to changes in development workflows, join the newsletter.