Agent Client Protocol: A Wire Standard for Editor-Agent Communication

The Problem ACP Solves

Every code editor that wants to integrate with a coding agent faces the same choice: build a custom protocol or adopt someone else's. Custom protocols couple you to one agent vendor. Adopting an existing one usually means adopting that vendor's ecosystem. ACP positions itself as the neutral layer. The README defines it as standardizing communication between code editors, which it calls interactive programs for viewing and editing source code, and coding agents, which are programs using generative AI to autonomously modify code. The target audience is clear: editor developers who want to support multiple agents, and agent developers who want to reach multiple editors without writing N integrations. This is a classic standards play, and the value depends entirely on adoption, which the README acknowledges by describing ACP as intended for broad adoption across the ecosystem.

How the Wire Protocol Works

ACP uses JSON-RPC as its envelope. The Rust schema crate defines request, response, notification, JSON-RPC envelope, and protocol-version types. The key mechanism is the initialize handshake, where the client and agent exchange a protocolVersion. That negotiated version determines wire compatibility, not the crate version or the schema release version. The README is explicit: consumers should not infer wire compatibility from the crate or schema release version alone. Within a protocol version, capabilities exchanged during initialization decide which optional messages and features are supported. This design separates three concerns: the wire protocol version, the artifact structure for SDK generators, and the optional features a peer supports. It is a sensible separation, but it places a burden on implementers to handle version negotiation correctly from day one.

Repository Layout and the Two Crates

The repository is primarily a Rust crate named agent-client-protocol-schema, which is the lower-level protocol type surface. It provides the data model for ACP wire messages and is meant for schema-oriented tooling and code generation inputs. If you are implementing a Rust agent or client, the README points you to a separate, higher-level runtime crate, agent-client-protocol, which provides the client and agent runtime APIs. That runtime crate lives in a different repository according to the integration links, which point to a rust-sdk repository for examples. The schema directory contains versioned JSON Schema artifacts under schema/v1 and schema/v2. When a schema release is published, the versioned .json files are attached to the corresponding schema-v* GitHub release, and that is the recommended download surface for SDK generators and release automation. So the repository is a schema source, not the runtime implementation.

Getting Started: Commands and Config Keys

For Rust users, the README directs you to add the agent-client-protocol crate for runtime work, not the schema crate, unless you need low-level types. The example files are agent.rs and client.rs in the rust-sdk repository. For other languages, the integration list includes Kotlin via acp-kotlin, Java via java-sdk, Python via python-sdk, and TypeScript via the @agentclientprotocol/sdk npm package. Each has its own examples directory. There is no single install command in the README, but the pattern is clear: pick your language SDK, add it as a dependency, and look at the examples for the initialize handshake. The protocol version is exchanged during initialize via protocolVersion, and the schema meta files also contain a version field that describes the ACP protocol version. If you are generating SDKs, you download the versioned JSON Schema files from the GitHub release, not from the crate.

Versioning Is the Sharp Edge

The versioning scheme is the most subtle part of this project. The Rust crate version and the JSON Schema release versions describe the artifacts themselves, not the wire protocol. Two different schema releases can describe the same wire-compatible ACP protocol version while having different schema structure for SDK generators. The README gives an example: a release might change how definitions are organized, named, or emitted in the JSON Schema, affecting downstream code generation without changing the JSON messages exchanged. This means you cannot look at a schema version number and know whether your agent and editor will interoperate. You must negotiate protocolVersion at runtime. That is a genuine failure mode for teams that assume semantic versioning on the artifact implies wire compatibility. It also means a schema release can break your code generator even though the wire protocol is unchanged. The current stable protocol version is 1, and there is a schema-v2.0.0-alpha.3 release, so v2 is in progress but not stable.

Limitations and Wrong Use Cases

The most obvious limitation is that this repository is a schema and a low-level Rust crate, not a complete implementation. If you are not using Rust, Kotlin, Java, Python, or TypeScript, you have no official SDK here, only community libraries. The README does not describe any transport, authentication, or error-handling semantics beyond the JSON-RPC envelope, so those are presumably left to the protocol specification on the website, which is not included in the material. ACP is also the wrong tool if you need a tightly coupled, vendor-specific integration with deep editor-specific features that the protocol does not cover. The protocol standardizes communication, but it cannot standardize every editor's UI model or every agent's tool-calling behavior. If you only need to connect one editor to one agent and never plan to support others, the overhead of a negotiated protocol version and capability exchange may be unnecessary.

Alternatives and How They Differ

The most direct alternative is the Model Context Protocol (MCP), which also standardizes communication between AI tools and hosts, but MCP focuses on connecting AI models to tools and data sources, not on editor-agent interaction specifically. ACP's scope is narrower: it targets code editors and coding agents that modify code. Another alternative is Language Server Protocol (LSP), which standardizes editor-language tooling communication. LSP is about providing language features like completion and diagnostics, not about autonomous code modification by an AI agent. The difference in approach is that LSP is a client-server model for language intelligence, MCP is a model-tool model for AI context, and ACP is an editor-agent model for autonomous coding. If you already use LSP for language features, ACP would sit on top of that, not replace it. The README does not mention these alternatives, but the distinction matters for choosing the right standard.

Maintenance and License Implications

The repository shows active maintenance: the last push is 2026-08-20, with releases for the Rust crate v1.7.0, schema v1.21.0, and schema v2.0.0-alpha.3 on the same day. The project is not archived. The license is Apache-2.0, and the contribution policy states that no Contributor License Agreement is required; contributors agree that their contributions are licensed under Apache-2.0. That is a permissive license, which means you can use the schema and Rust types in commercial products, but you should check the specific SDKs in other languages for their own licenses. The maintenance cost for adopters is tied to the versioning complexity: you must track schema releases for generator compatibility and protocol versions for wire compatibility separately. The README advises using artifact versions to manage compatibility with the repository's Rust and schema outputs, which implies you should pin versions carefully in your build system.

Editorial conclusion

Adopt ACP if you build a code editor or a coding agent and want a vendor-neutral wire protocol instead of a proprietary integration. Do not adopt it if you need a full runtime implementation in a language other than Rust, Kotlin, Java, Python, or TypeScript, or if you expect the schema crate version to reflect wire compatibility. Before committing, verify the negotiated protocolVersion in your initialize handshake, check which optional capabilities your peer supports, and confirm that the schema release version you pin matches the artifact layout your code generator expects. The protocol is stable at version 1, but the repository's own versioning warns you not to infer wire compatibility from artifact versions, so test that handshake early.

Official sources

1. Official documentation
2. Official README
3. Project repository
4. Release notes