Agent Client Protocol [What It Changes]

TL;DR

• Agent Client Protocol is an open standard for how a code editor talks to a coding agent, the way LSP standardized how editors talk to language servers.

• As of 2026 the stable wire version is 1; JetBrains IDEs, Zed, and a growing client list speak it, and a v2 draft landed on 20 July 2026 without retiring v1.

• ACP is not MCP (agent-to-tool) and not A2A (agent-to-agent). Version 1 does not mean every plugin works in every IDE.

• A two-truck HVAC shop, a 10-person agency, or a solo clinic should care when they hire a developer or an agency that lives in one IDE: the agent should move if the editor changes.

According to AICPA, 62% of firms reported cloud-workflow adoption.

According to Journal of Accountancy, the mid-market close still runs 8-10 business days.

According to Thomson Reuters, tax-prep utilization hits 85-95% in March and April.

According to NFIB, 44% of small businesses cite time-management as a top challenge.

According to NFIB, 44% of small businesses cite time-management. According to SBA Office of Advocacy, 33M+ small businesses sit in the 2025 profile. According to Goldman Sachs, 62% of SMBs reported workflow-tool ROI inside 12 months.

Key Takeaways

• ACP is the IDE-to-agent pipe. MCP remains the agent-to-tool pipe. Mixing the acronyms is how buyers buy the wrong thing.

• JetBrains and Zed jointly operate the protocol and the agent registry; AWS lists ACP among the open protocols it invests in, including via Kiro.

• The GitHub repository states the current stable ACP protocol version is 1, with schema artifacts for v1 and v2.

• v2 is a draft. Implementers are told to keep v1 and not ship v2 by default until it stabilizes.

• 1.0 on the wire is not "every agent works everywhere." Registry listing, auth type, and client support still have to match.

What Agent Client Protocol is, in one sentence

Agent Client Protocol is an open protocol that standardizes communication between code editors and coding agents so any compatible agent can run inside any compatible editor. That is the entity. It is not a model, not a SaaS seat, and not a claim that Xcode, JetBrains, and Zed now share a plugin binary.

A two-truck HVAC company does not install JetBrains. It still pays a contractor who does. When that contractor's agent only works in one editor, the shop is locked to that contractor's toolchain the next time a dispatch portal needs a patch. A 10-person marketing agency hits the same wall when the front-end person uses Cursor and the WordPress person uses VS Code and neither agent can be reviewed in the other's window. A solo clinic's "we have a developer on Fridays" setup dies when the Friday person leaves and the next person opens a different IDE.

ACP is the LSP move for agents: implement the protocol once, reach every supporting editor. The Language Server Protocol already proved the pattern for autocomplete and go-to-definition. ACP is the same idea for an agent that edits files, streams progress, and asks permission before it runs a tool.

Shops already comparing practice-management stacks, such as Clio alternatives, know what a closed integration feels like. ACP is the opposite bet on the editor side: the agent is supposed to be swappable.

Why a small operator should care before the deep dive

According to the SBA Office of Advocacy, the United States contains 36.2 million U.S. small businesses. Almost none will implement JSON-RPC over stdio. They will still pay someone who opens an IDE.

According to the same SBA release, those firms account for almost 46 percent of private-sector employment. The Advocacy homepage restates 62.3 million small-business employees. That is a lot of operators whose "IT person" cannot afford a second custom agent integration.

The NIST AI Risk Management Framework is the voluntary U.S. frame for governing AI systems. ACP's local subprocess design — the editor launches the agent, they speak JSON-RPC, no extra network listener required for the local case — is one way to keep the trust boundary on the laptop. NIST does not certify ACP.

If the office already automates assistant follow-up as in five ways to automate assistant tasks, the parallel is simple: do not rebuild the follow-up path every time the chat tool changes. Teams already routing code-review notes, ticket text, and deploy checklists through US Tech Automations workflows can treat an ACP-compatible agent as a model-and-editor swap on that same path, not a rebuild of the ticket system.

A shop that wants the wider automation map can start from the state of small-business automation and come back here for the protocol.

What shipped, and what "1.0" actually means

The ACP introduction says the protocol standardizes editor/IDE-to-agent communication for local and remote scenarios, reuses MCP JSON representations where possible, and uses Markdown as the default for user-readable text. Local agents run as subprocesses over stdio. Remote agents over HTTP or WebSocket are called out as a work in progress.

According to the ACP GitHub repository, the current stable ACP protocol version is 1. Wire compatibility is negotiated during initialize via protocolVersion, not inferred from the Rust crate version. Schema artifacts live under schema/v1 and schema/v2.

According to the 20 July 2026 v2 draft note, the project has shipped 15+ RFDs since releasing v1, and v2 is a draft that must not ship as the production default. Implementers should support v1 and v2 side by side. That is the honest "1.0" limit: the stable wire is v1; v2 is for testing.

JetBrains' ACP page describes ACP as a shared protocol for IDE–agent interoperability, developed openly by JetBrains and Zed, with clients including JetBrains IDEs, Zed, Neovim (plugin), Emacs, Obsidian (plugin), marimo, Sidequery, and AionUI, plus agents including Junie and Kiro CLI.

Zed's ACP page lists the same joint story: any agent that speaks ACP can use Zed's multi-file editing and review tools; third-party agents do not touch Zed servers; the protocol is Apache-licensed. Zed's page names Visual Studio Code as a client, plus a long agent list (Claude Agent, Codex CLI, Gemini CLI, Cursor, Devin, GitHub Copilot, Junie, Kiro CLI, OpenCode, and others).

As of June 2026 that client list is the shipped footprint. "Xcode" in the launch conversation is an editor in the same class — Apple's IDE — not a claim that every Xcode plugin is an ACP client. Confirm Xcode support on the current clients list and vendor pages before treating it as done.

AWS's 6 August Agent Plugins post is the same summer's protocol posture: open protocols, closed harness. AWS lists MCP, ACP, x402, and Agent Plugins as standards it invests in, and says Kiro is rolling out Agent Plugins support. Agent Plugins 1.0.0 standardizes packaging for Agent Skills and MCP servers. That is not ACP. It is the box the skills ship in. Kiro-ACP extensions for live steering and permissions are AWS's harness on top of the open wire, not a replacement for v1.

Sources: ACP GitHub; v2 draft; AWS Agent Plugins; LSP; JetBrains ACP.

How the protocol actually works

The editor is where the person sits. The agent is a program that plans, edits, and runs tools. ACP says they speak a shared JSON-RPC language so the editor does not write a custom adapter per agent.

Locally, the IDE launches the agent as a child process and talks over stdin/stdout. That is the same shape LSP used. The LSP overview is JSON-RPC between tool and server; ACP reuses that lesson and adds agentic UX types such as diffs.

The registry is how a human finds an agent without hand-editing JSON. According to JetBrains, JetBrains and Zed launched the official ACP Agent Registry on 28 January 2026 (Zed's registry post is the paired announcement). In JetBrains IDE 2025.3.2+ with JetBrains AI plugin 253.30387.147, a user opens Settings → Tools → AI Assistant → Agents (or "Install From ACP Registry…"), clicks Install, and the agent appears in the AI Chat tool window. A JetBrains AI subscription is not required to use ACP agents; the agent vendor's own subscription still is. Official docs live at agentclientprotocol.com.

The same JetBrains post lists launch-era registry agents including Auggie CLI, Factory Droid, Gemini CLI, GitHub Copilot, Mistral Vibe, OpenCode, and Qwen Code. Manual acp.json remains for agents not yet listed. Submissions go to the registry repository; JetBrains says listings currently require Agent Auth or Terminal Auth per AUTHENTICATION.md.

Official libraries on the GitHub readme include Kotlin, Java, Python, Rust, and TypeScript SDKs. That is the implementation surface, not a compatibility matrix. Kiro's product home is kiro.dev.

v2's big themes, from the draft announcement, are: session updates outside a user "turn"; uniform streaming/patch semantics for messages and tool calls; structured file changes instead of oldText/newText diffs; permission prompts with their own title and subject; and forward-compatible unknown enum variants. None of that is production-default until the draft stabilizes.

Kiro for iOS shows why live steering matters: three modes (chat, spec, autonomy), cloud sessions that keep running, diffs as native cards, iOS 26+, gated preview. AWS can extend ACP with extra methods in Kiro without those methods being the open v1 core. That is the "open protocol, closed harness" line.

Sources: JetBrains registry post; ACP GitHub; v2 draft; Kiro for iOS.

Transactional firms comparing Smokeball and Clio Manage already know a "standard" that only one vendor ships is not a standard. ACP is only as portable as the clients and agents that implement the same protocolVersion.

USTA analysis: v1 stay-versus-v2-draft

USTA analysis. Working only from figures already cited above: stable protocol version 1, 15+ RFDs shipped on v1, v2 draft dated 20 July 2026, and JetBrains registry live since 28 January 2026.

• Days from registry launch to the v2 draft: 28 January 2026 to 20 July 2026 is 173 days (31−28=3 in January, plus 28+31+30+31+30+20 for Feb–July 2026; 2026 is not a leap year, so February is 28).

• The project used those 173 days to add 15+ RFDs without a forced v2 migration, which is the "evolve v1 in place" claim in the draft note.

• 15 RFDs / 173 days is about one RFD per 11.5 days if you take the floor of 15. That is cadence arithmetic on the project's own counts, not a quality score.

Sources for inputs: JetBrains registry post; v2 draft. Results are USTA arithmetic, not a benchmark.

Do not read 11.5 days as "ACP ships a breaking change every two weeks." The draft says the opposite: RFDs were additive on v1; v2 is a focused set of breaking cleanups still in draft.

What this does not establish

ACP does not establish that every JetBrains marketplace plugin is an ACP agent. It does not establish that Xcode, VS Code, and Neovim have feature-parity clients. Zed lists VS Code; JetBrains lists Neovim via plugin. Check the current matrix.

It does not establish that Agent Plugins 1.0.0 and ACP v1 are the same standard. AWS's Agent Plugins post is packaging for skills and MCP. ACP is the editor session.

It does not establish a public price. Agents keep their own subscriptions. JetBrains said a JetBrains AI subscription is not required for ACP agents.

It does not establish remote-agent production readiness. The ACP introduction says full remote support is a work in progress.

The Register's 2025 JetBrains ACP coverage, linked from Zed's page, is earlier industry reporting on JetBrains backing the standard. It is not a 2026 1.0 certification.

A buyer's evaluation sequence

None of the sourced pages say ACP files a pull request for you. Use four checkpoints.

If the Friday developer leaves, the test is whether the next person can install the same agent from the registry in their IDE. If they cannot, you did not buy a protocol. You bought a plugin.

A startup that wants the agent path without living in JetBrains can look at agentic workflows and then compare. US Tech Automations is the logging and approval layer if an ACP agent proposes a deploy that still needs a human hold.

Pricing on this site is that layer, not an IDE quote.

Signal vs Speculation

Demonstrated signal: as of 2026 the ACP GitHub repo states stable protocol version 1; JetBrains and Zed document a shared protocol and a registry launched 28 January 2026 with IDE 2025.3.2+ and plugin 253.30387.147; the v2 draft published 20 July 2026 reports 15+ RFDs since v1 and tells implementers not to drop v1; AWS's 6 August Agent Plugins post lists ACP beside MCP as an open protocol and ships Agent Plugins 1.0.0 for skills/MCP packaging; LSP remains the analogy, currently at spec 3.18; SBA Advocacy counts 36.2 million U.S. small businesses; remote ACP is still described as in progress.

Our read: over the next 12–36 months, small shops will not "adopt ACP." They will notice whether the contractor can change IDEs without losing the agent. If v2 stays in draft and v1 keeps taking RFDs, the practical move is to require protocolVersion 1 and a registry listing in any development contract, then keep merge approval on a human path. If a vendor's "ACP support" is actually a closed harness with extra methods, treat those extras as optional, the same way AWS's Kiro steering is extra on top of the open wire.

FAQ

What is Agent Client Protocol?

It is an open protocol for communication between code editors and coding agents, so a compatible agent can run in a compatible IDE without a custom integration. Locally it uses JSON-RPC over stdio.

Is ACP the same as MCP?

No. MCP connects agents to tools and data. ACP connects editors to agents. AWS discusses both as separate standards in its Agent Plugins post.

Does version 1 mean every agent works in every IDE?

No. The stable wire is version 1. Each client and agent still has to implement it, pass registry auth rules, and negotiate capabilities. v2 is a draft as of 20 July 2026.

Which editors are in the sources?

JetBrains IDEs and Zed are the co-governors. JetBrains and Zed pages also list Neovim, Emacs, Obsidian, VS Code, and others at various completeness. Confirm the live client list before buying.

Do I need a JetBrains AI subscription?

JetBrains says no for ACP agents. You still need whatever subscription the agent vendor sells.

What should a small shop put in a contractor agreement?

Name the IDE, require ACP protocol version 1, require registry or documented acp.json, and keep humans on merge. Do not require v2 draft.

What to do next

ACP is the editor-to-agent pipe at protocol version 1, with a v2 draft that is not the production default. The honest limit is incomplete client parity and remote-agent work still in progress.

If the next step is to keep that agent behind an approval step instead of letting it ship from the IDE unsupervised, start from agentic workflows for ACP-style editor agents on US Tech Automations, then set the hold on pricing.