Open Source Protocol

Agent Client Protocol (ACP) for AI Coding Agents

ACP standardizes communication between code editors and AI coding agents. Local agents commonly use JSON-RPC over stdio, while the protocol also supports emerging remote workflows.

Tired of Building Custom Integrations for Every Editor-Agent Pair?

AI coding agents and editors are tightly coupled, forcing developers to choose between their preferred tools or spend weeks on custom integration work.

Weeks Wasted on Integration
Spending weeks building custom code just to connect your favorite AI agent to your editor? Every new agent-editor pair means starting from scratch with custom integration work.
Can't Use Your Favorite Tools Together
Love Neovim but want to use Claude Code? Your favorite AI agent only works with VS Code but you prefer Zed? Stop compromising on your development workflow.
Stuck with Vendor Lock-in
Once you invest time learning an AI coding tool, you're trapped in their ecosystem. Want to switch editors or try a new agent? Start the integration nightmare all over again.

ACP Solves This - Build Once, Integrate Everywhere

By providing a standardized protocol for agent-editor communication, similar to how the Language Server Protocol (LSP) standardized language server integration. Agents that implement ACP work with any compatible editor, and editors that support ACP gain access to the entire ecosystem of ACP-compatible agents.

How Agent Client Protocol Works

ACP assumes that the user is primarily in their editor, and wants to reach out and use agents to assist them with specific tasks. Built on proven JSON-RPC communication patterns.

JSON-RPC Over Stdio

Subprocess Communication

Agents run as sub-processes of the code editor, ensuring secure and efficient communication.

MCP Compatibility

Re-uses JSON representations from MCP where possible, with custom types for agentic coding UX elements.

Markdown Support

Default format for user-readable text is Markdown, providing rich formatting without HTML complexity.

Example ACP Message

{
  "jsonrpc": "2.0",
  "method": "agent/prompt",
  "params": {
    "content": "Refactor this function",
    "context": {
      "file": "src/utils.ts",
      "selection": {
        "start": { "line": 10, "character": 0 },
        "end": { "line": 25, "character": 0 }
      }
    }
  },
  "id": 1
}
Session Management
Robust session setup and management between editors and agents, with proper initialization and teardown procedures.
Rich Content Types
Support for displaying diffs, code blocks, file system operations, and other specialized content types for coding workflows.
Tool Integration
Extensible tool calling system that allows agents to interact with file systems, run commands, and perform complex operations.

Why Choose Agent Client Protocol?

Solve integration overhead, compatibility issues, and developer lock-in with our standardized protocol.

Universal Compatibility
Agents that implement ACP work with any compatible editor. No more custom integrations for each editor-agent combination.
Reduced Integration Overhead
Eliminate the need for custom work on every new agent-editor combination. Build once, integrate everywhere.
Developer Freedom
Choose the best tools for your workflow without being locked into specific editor-agent combinations.
JSON-RPC Communication
Built on proven JSON-RPC over stdio, similar to LSP. Reliable, standardized communication protocol.
Growing Ecosystem
Join a growing community of developers building the future of AI-assisted coding with standardized protocols.
Rich UX Elements
Support for diffs, markdown formatting, and other agentic coding UX elements that enhance developer experience.

Real-World Use Cases for AI Agent Integration

See how developers and organizations are using ACP to build better AI-assisted coding experiences without vendor lock-in.

Code Refactoring & Optimization

AI agents can analyze code patterns, suggest improvements, and automatically refactor code while maintaining compatibility with your preferred editor's workflow and keybindings.

Automated Testing & Documentation

Generate comprehensive test suites and documentation directly within your editor, with agents that understand your project structure and coding conventions.

Cross-Language Development

Work seamlessly across multiple programming languages with agents that can translate patterns, suggest equivalent implementations, and maintain consistency across your polyglot codebase.

Security & Code Review

Implement AI-powered security scanning and code review processes that integrate directly into your development workflow, catching vulnerabilities before they reach production.

Team Collaboration

Enable consistent AI assistance across your entire development team, regardless of individual editor preferences, ensuring uniform code quality and development practices.

Custom Workflow Automation

Build specialized agents for your unique development workflows, from database migrations to API generation, all integrated seamlessly into your existing editor environment.

ACP Clients & Compatible Coding Agents

The ecosystem now spans editors, IDEs, desktop clients, CLIs, and a growing registry of authenticated agents.

Editors & Client Surfaces

Zed & JetBrains IDEs
First-class editor and IDE integrations
Neovim & Emacs
Community plugins including CodeCompanion and agent-shell
VS Code, Obsidian & Qt Creator
Extensions and plugins connect additional workflows

Agents & Adapters

Codex CLI & Claude Agent
Available through maintained ACP adapters
Gemini CLI & GitHub Copilot
ACP-compatible command-line agent workflows
Docker cagent, Goose, OpenCode & More
Discover authenticated agents in the official ACP Registry

Find the right ACP pairing

Compare client surfaces, agent availability, adapters, and capability support.

View Compatibility Guide

Complete Documentation & Libraries

Everything you need to implement ACP in your editor or build your own AI coding agent.

Protocol Overview
Learn the core concepts, architecture, and communication patterns of ACP.
TypeScript Library
Official TypeScript/JavaScript library for implementing ACP clients and servers.
Rust Library
High-performance Rust implementation for building fast, reliable ACP integrations.
Python & Java SDKs
Build ACP clients and agents with official Python and Java libraries.
Kotlin SDK
Use the official Kotlin SDK for JVM-based ACP integrations.
ACP Registry
Browse the curated registry of agents that implement ACP authentication.

Get Started with ACP

Whether you're building an editor integration or developing an AI agent, we have the resources to get you started quickly.

For Editor Developers
Integrate ACP support into your code editor to unlock the entire ecosystem of AI coding agents.
Study the protocol specification and architecture
Implement JSON-RPC communication over stdio
Choose an official TypeScript, Rust, Python, Java, or Kotlin SDK
Test with existing ACP-compatible agents
For Agent Developers
Build AI coding agents that work seamlessly across all ACP-compatible editors.
Learn the session setup and prompt turn protocols
Implement tool calling for file system operations
Handle rich content types like diffs and code blocks
Test with Zed, Neovim, and other supported editors

Ready to Integrate AI Agents?

Start building with the Agent Client Protocol today. Join the growing ecosystem of developers creating the future of AI-assisted coding.

Frequently Asked Questions

Everything you need to know about the Agent Client Protocol