← Back to research
·12 min read·opensource

Agent Client Protocol

Agent Client Protocol is Zed's open standard connecting any coding agent to any editor — "LSP for agents." Apache 2.0, 3.4K stars, a public registry co-launched with JetBrains in January 2026, and the headline feature of Zed 1.0. Agent-to-client, not agent-to-agent.

https://agentclientprotocol.com ↗
agent-frameworksagent-infrastructureopen-sourcegithub

Key takeaways

  • ACP became real infrastructure in under a year: created June 2025, the headline feature of Zed 1.0 (April 29, 2026), built into JetBrains IDEs since December 2025, with a public agent registry co-launched with JetBrains on January 28, 2026
  • It is the LSP model applied to coding agents — JSON-RPC 2.0 between an editor and an agent subprocess, with sessions, permission requests, and file/terminal access — turning the N×M agent-editor integration problem into N+M
  • Naming matters: "ACP" historically meant IBM's Agent Communication Protocol, which merged into A2A and was archived in August 2025; Zed's protocol has effectively claimed the acronym, and it is agent-to-client, not agent-to-agent

FAQ

What is the Agent Client Protocol?

An open, Apache 2.0-licensed protocol created by Zed that standardizes how coding agents (Claude Code, Codex CLI, Gemini CLI, and others) communicate with editors and IDEs — analogous to the Language Server Protocol, but for agents.

How much does the Agent Client Protocol cost?

Nothing — it is a free, open-source protocol specification with Apache 2.0-licensed libraries; there is no commercial product attached.

How does the Agent Client Protocol work?

The editor launches the agent as a subprocess and the two speak JSON-RPC 2.0 — capability negotiation, sessions, prompt turns with streaming updates, permission requests before sensitive operations, and client-provided file system and terminal access. Remote agent support is a work in progress.

How is the Agent Client Protocol different from A2A?

A2A standardizes agent-to-agent communication across organizations; ACP standardizes agent-to-client communication between one coding agent and the editor a human is sitting in — adjacent layers, not competitors.

Executive Summary

The Agent Client Protocol (ACP) is Zed Industries' open standard for connecting any coding agent to any editor — explicitly modeled on the Language Server Protocol, which turned the N×M problem of language-times-editor integrations into N+M. ACP does the same for agents: an editor launches an agent as a subprocess, the two speak JSON-RPC 2.0, and the agent gains sessions, streaming progress updates, permission-gated tool execution, and client-provided file system and terminal access.[1] The repository was created in June 2025 and sits at 3.4K stars and 271 forks under an Apache 2.0 license, with the latest release (v0.13.6) shipped June 5, 2026 and commits as recent as June 11, 2026 (GitHub API).[2]

What distinguishes ACP from most 2025-vintage agent protocols is shipped adoption rather than consortium press releases. JetBrains added ACP support to its IDEs in December 2025,[3] then co-launched the public ACP Agent Registry with Zed on January 28, 2026 — a curated directory where agent authors register once via a GitHub pull request and get one-click installation across all compatible clients, replacing hand-edited JSON configuration.[4][5] ACP was then the headline feature of Zed 1.0 on April 29, 2026, with Claude Code, Codex CLI, Gemini CLI, and OpenCode running inside the editor at launch.[6][7] One important naming caveat: "ACP" previously meant IBM's Agent Communication Protocol, an agent-to-agent standard that merged into A2A and was archived in August 2025 — Zed's protocol has effectively inherited the acronym, but it operates at a different layer (agent↔client, not agent↔agent).[8]

AttributeValue
CreatorZed Industries; registry co-developed with JetBrains[4]
LaunchedRepo created June 23, 2025[2]
LicenseApache 2.0[2]
GitHub Stars3.4K (271 forks), as of June 2026[2]
Latest Releasev0.13.6, June 5, 2026[2]
RegistryPublic ACP Agent Registry, launched January 28, 2026[4]

Product Overview

ACP standardizes the conversation between a coding agent and the surface a developer actually works in. Instead of every agent vendor building a VS Code fork or a per-IDE plugin, the agent implements ACP once and runs inside any compliant client; instead of every editor integrating each agent by hand, the editor implements ACP once and gets the whole catalog.[1] Zed's ACP page lists an ecosystem of 60+ agents — including Claude Code (Anthropic), Gemini CLI (Google), GitHub Copilot, Cline, OpenHands, Goose, Docker's cagent, and Factory Droid — and emphasizes a privacy property of the architecture: third-party agents talk to the editor locally, so "nothing touches our servers."[9]

The registry is the distribution layer on top of the protocol. Agent authors submit a pull request to register; users browse and install agents with one click from inside Zed or a JetBrains IDE, and authors push updates without waiting on editor extension-review cycles. The launch catalog included Claude Code, Codex CLI, GitHub Copilot CLI, OpenCode, and Gemini CLI.[4][5]

Key Capabilities

CapabilityDescription
Initialization & capabilitiesClient and agent negotiate supported features at connection time[1]
SessionsCreate or resume conversational sessions with an agent[1]
Prompt turnsUser messages in; streaming session/update progress notifications out; cancellable mid-flight[1]
Permission requestsAgents must request user authorization before sensitive tool execution[1]
File system methodsClient-mediated read/write of text files, gated by explicit capabilities[1]
Terminal methodsCreate terminals, manage output, wait for exit, kill processes[1]
Registry distributionRegister once via PR; one-click install in every compatible client[4]

Product Surfaces

SurfaceDescriptionAvailability
ZedNative agent panel; ACP was the headline Zed 1.0 featureGA[6]
JetBrains IDEsACP support since December 2025; built-in registry supportGA[3][5]
Other editorsZed cites integration across VS Code, Neovim, and Emacs clientsVaries by client[9]

Technical Architecture

ACP is JSON-RPC 2.0 with two message types — methods (request/response) and notifications (one-way) — flowing bidirectionally between client and agent. The lifecycle runs initialization → optional authentication → session creation/resumption → prompt turns, with the agent streaming session/update notifications during processing and the client able to send session/cancel to interrupt.[1] In the local model, the agent runs as an editor subprocess; full support for remote, cloud-hosted agents is documented as a work in progress, with collaboration underway with agentic platforms.[1]

The inversion at the heart of the design: the client owns the dangerous capabilities. File access and terminals are client methods the agent must ask for, and permission requests put a human approval gate in front of tool execution — which is how an editor can host an arbitrary third-party agent without granting it unmediated machine access.[1]

Key Technical Details

AspectDetail
DeploymentAgent as local editor subprocess; remote agents in progress[1]
Wire formatJSON-RPC 2.0; methods + notifications[1]
IntegrationsZed, JetBrains IDEs natively; registry for agent distribution[5]
Open SourceApache 2.0; spec and libraries on GitHub[2]

Strengths

  • Two real editor vendors shipped it — Zed made ACP the headline of its 1.0 release and JetBrains built it into its IDEs and co-launched the registry; that is production adoption by the two most credible non-Microsoft editor makers, not a paper consortium.[6][5]
  • The LSP playbook is proven — solving N×M integration with a neutral protocol worked once at industry scale, and ACP copies the architecture deliberately, down to JSON-RPC and editor-subprocess transport.[1]
  • A distribution layer, not just a spec — the registry's register-once, install-everywhere model (with vendor-independent update cycles) is the piece most agent protocols never built.[4]
  • The agents that matter are on it — Claude Code, Codex CLI, GitHub Copilot CLI, Gemini CLI, and OpenCode were in the registry at launch, and Zed's ecosystem page lists 60+ agents.[4][9]
  • Permission-gated by construction — human approval in front of tool execution and client-owned file/terminal access is the right trust boundary for hosting third-party agents.[1]
  • Fast, active iteration — v0.13.6 on June 5, 2026, with commits the week of this profile.[2]

Cautions

  • Pre-1.0 spec — at v0.13.x the protocol is still iterating rapidly; implementers should expect breaking changes until a stable release lands.[2]
  • The acronym is a minefield — IBM's archived Agent Communication Protocol, plus AG-UI and A2A, make "ACP" genuinely ambiguous in search results and vendor decks; 2025-era protocol explainers usually mean the dead IBM one.[8][10]
  • Microsoft is absent — VS Code, the largest editor by share, has no first-party ACP support; coverage comes from community clients, and Copilot's home turf gives Microsoft little incentive to commoditize agent-editor integration.[9]
  • Remote agents are unfinished — the local-subprocess model is solid, but cloud-hosted agent support is explicitly a work in progress, which matters as agents move server-side.[1]
  • Vendor-steered governance — the spec is driven by Zed (with JetBrains on the registry), not a foundation; there is no Linux Foundation-style neutral home like A2A's, so competitors must trust a rival editor's roadmap.[4]

What Developers Say

The August 2025 Hacker News thread on ACP drew 281 points and 98 comments — broadly hopeful about the LSP analogy, with skepticism about protocol proliferation and the name.[10]

"Really hope for this to get traction so I'm not bound to the usual IDE" — baggiponte on Hacker News[10]

"Seriously. I really hope this puts an end to the crappy VS Code forks so Zed can start getting the credit it's due." — WD-42 on Hacker News[10]

"I don't see why we need so many protocols. In such a greenfield tech, many are eager to define rules." — hari-trata on Hacker News[10]

"With already agentcommunicationprotocol.dev (ACP) same name seems confusing now. even though differences are there in both." — darkbatman on Hacker News[10]

"One great reason is to avoid M*N problem" — ivanjermakov on Hacker News, answering the "why another protocol" objection[10]

Pricing & Licensing

TierPriceIncludes
Open sourceFreeProtocol spec, libraries, and registry listing — Apache 2.0[2]

Licensing model: Apache 2.0 open-source protocol and libraries; no commercial product attached. The agents it connects (Claude Code, Copilot CLI, etc.) carry their own pricing.[2]

Hidden costs: None at the protocol layer; integration effort and pre-1.0 churn are the real costs.[2]

Competitive Positioning

ACP is agent↔client; the protocols it is most often lumped with are agent↔agent or agent↔tool. The honest framing is adjacency, not competition — a coding agent can speak ACP to its editor, MCP to its tools, and A2A to other agents simultaneously.

Direct Competitors

CompetitorDifferentiation
Google A2AA2A standardizes agent-to-agent communication across trust boundaries (Linux Foundation, 150+ orgs); ACP standardizes one agent talking to the editor in front of a human. Different layers — an HN commenter's question of whether A2A still needs a client "surface" protocol is exactly the gap ACP fills[10]
ACP (IBM, archived)The previous owner of the acronym — IBM's REST-based agent-to-agent protocol, merged into A2A in August 2025 and archived; Zed's ACP is unrelated and actively developed[8]
MCPMCP connects agents to tools and data; ACP connects agents to editing surfaces. Complementary — most ACP agents are also MCP clients[1]
LSPThe architectural ancestor: same N×M-to-N+M move, same JSON-RPC transport, applied to agents instead of language servers[1]
Proprietary integrations (Cursor, VS Code forks)The status quo ACP attacks: each agent vendor shipping its own fork or per-editor plugin instead of one protocol[9]

When to Choose Agent Client Protocol Over Alternatives

  • Choose ACP when: you build a coding agent and want it inside Zed and JetBrains IDEs without per-editor plugins, or you build an editor/client and want the agent catalog for free.
  • Choose Google A2A when: the problem is agents coordinating with other agents across organizational boundaries — a different layer entirely.
  • Choose MCP when: the problem is connecting an agent to tools and data sources rather than to an editing surface.
  • Choose a proprietary integration when: you only target VS Code, where first-party ACP support does not exist.[9]

Ideal Customer Profile

Best fit:

  • Coding-agent vendors (CLI or otherwise) who want IDE distribution — one implementation plus a registry PR reaches Zed and JetBrains users[4]
  • Editor, TUI, and notebook builders who want every major agent without N bespoke integrations[1]
  • Developers who want to pick agent and editor independently — Claude Code in a JetBrains IDE, Codex in Zed[5]

Poor fit:

  • Teams needing agent-to-agent orchestration — that is A2A's layer, not ACP's
  • VS Code-only shops, absent first-party Microsoft support[9]
  • Anyone requiring a frozen, stable spec today — ACP is pre-1.0 and moving[2]

Viability Assessment

FactorAssessment
Financial HealthN/A — open protocol; sustained by Zed Industries with JetBrains co-investment in the registry[4]
Market PositionStrong and uncontested in its niche — no rival agent↔editor standard has comparable adoption; the open flank is Microsoft/VS Code[5][9]
Innovation PaceHigh — registry (Jan 2026), Zed 1.0 flagship (Apr 2026), v0.13.6 (Jun 5, 2026), active commits[2]
Community/Ecosystem3.4K stars, 271 forks; 60+ agents listed; substantive HN debate (281 points)[2][9][10]
Long-term OutlookFavorable — two editor vendors shipping is the network-effect seed LSP had; risks are pre-1.0 churn and Microsoft abstention

In under a year ACP went from new repo to the headline feature of a 1.0 editor release and a JetBrains co-launched registry — a faster path to shipped, multi-vendor adoption than any other agent protocol of the 2025 cohort.[6][5] The structural question is whether a Zed-steered spec can become neutral infrastructure if Microsoft never joins.

Bottom Line

The Agent Client Protocol is the most credible "LSP for agents" attempt because it repeated LSP's actual success conditions: a real editor shipped it as a flagship feature, a second major vendor (JetBrains) adopted it and co-built distribution, and the agents developers actually use — Claude Code, Codex CLI, Copilot CLI, Gemini CLI — are in the registry.[6][4] Just be precise about what it is: agent-to-client plumbing for coding tools, not agent-to-agent coordination — and not IBM's dead protocol that used to own the acronym.[8]

Recommended for: Coding-agent vendors seeking IDE distribution; editor and client builders who want the agent ecosystem in one integration; developers pairing their preferred agent with their preferred IDE.

Not recommended for: Cross-organization agent orchestration (use Google A2A); tool connectivity (use MCP); teams that need spec stability before a 1.0.

Outlook: Watch for a 1.0 spec release, the remote-agent story landing, and any first-party VS Code move — Microsoft adopting ACP would settle the standard; Microsoft countering with its own protocol is the scenario that fragments it.[1]

Research by Ry Walker Research • methodology

Sources

Share on XShare on LinkedIn