Agent Client Protocol (ACP) Open Standard: Running Any AI Coding Agent in Any IDE

By Vatsal Shah | 2026-07-31 | 7 min read

Table of Contents

1. Introduction
2. The IDE-Agent Coupling Problem
3. What is the Agent Client Protocol (ACP)?
4. ACP Architecture and JSON-RPC Schema
5. How MCP and ACP Work Together
6. Industry Adoption: Cognition, JetBrains, GitHub, Google
7. Comparison: Proprietary IDE Lock-In vs. Open ACP Standard
8. FAQ
9. About the Author
10. Conclusion

Introduction

Until recently, AI coding assistants were tightly coupled to specific IDE extensions or standalone desktop apps. Cursor required the Cursor editor; Devin ran inside Cognition's cloud sandbox; GitHub Copilot depended on VS Code or JetBrains custom plugins. If a developer wanted to combine Devin's deep autonomous planning with Claude Code's terminal execution inside IntelliJ IDEA, they were out of luck.

The formalization of the Agent Client Protocol (ACP) solves this fragmentation. Inspired by the success of the Language Server Protocol (LSP) and Model Context Protocol (MCP), ACP establishes a open, vendor-neutral standard for bi-directional communication between any AI coding agent and any client IDE interface.

The IDE-Agent Coupling Problem

Before ACP, building an AI agent required creating custom integration plugins for every IDE:

[Agent Engine] ──> Custom VS Code Extension
               ──> Custom JetBrains Plugin
               ──> Custom Neovim Plugin
               ──> Custom Eclipse Adapter

This vendor fragmentation resulted in:

• Duplicated Engineering: Agent builders spent 40% of their development time maintaining UI adapters across multiple editor platforms.
• Feature Parity Lag: Advanced features like multi-file diff previews or terminal command approvals worked on VS Code but lagged on JetBrains or vim.
• Vendor Lock-In: Developers were forced to change their primary IDE just to access specific frontier coding models.

What is the Agent Client Protocol (ACP)?

ACP standardizes how an editor passes code context, user instructions, file selection state, and terminal permissions to an external agent—and how the agent streams back proposed file diffs, terminal execution requests, and progress status.

Key capabilities standardized by ACP include:

1. Context Exchange: Passing active file content, cursor locations, git diff status, and open workspace structures.
2. Action Requests: Requesting file writes, file reads, terminal executions, and user permission approvals.
3. Structured UI Hints: Rendering multi-file diff previews, progress bars, and intermediate reasoning steps inside native editor UI components.

ACP Architecture and JSON-RPC Schema

Like LSP and MCP, ACP operates over standard JSON-RPC 2.0 via standard input/output (stdio) or WebSockets.

+-------------------+     JSON-RPC 2.0 (stdio/WebSocket)     +--------------------+
|     IDE Client    | <====================================> |    Agent Server    |
| (VSCode/IntelliJ) |    acp/initialize, acp/applyDiff      | (Devin/Claude/etc) |
+-------------------+                                        +--------------------+

Example ACP Message Exchange

1. Client Initializing Agent Session (acp/initialize):

{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "acp/initialize",
  "params": {
    "protocolVersion": "2026-06-01",
    "clientInfo": { "name": "IntelliJ IDEA", "version": "2026.2" },
    "workspaceRoot": "file:///e:/wamp/www/vatsalshah"
  }
}

2. Agent Requesting File Edit Approval (acp/requestDiff):

{
  "jsonrpc": "2.0",
  "id": 42,
  "method": "acp/requestDiff",
  "params": {
    "filePath": "app/Services/AuthService.php",
    "diff": "--- a/app/Services/AuthService.php\n+++ b/app/Services/AuthService.php\n@@ -12,3 +12,4 @@\n+    \$this->validateToken(\$token);\n",
    "explanation": "Adding token validation check before handling payload."
  }
}

How MCP and ACP Work Together

A common point of confusion is how ACP relates to Anthropic's Model Context Protocol (MCP). They are complementary protocols serving opposite sides of the AI agent architecture:

[External Tools & APIs] ◄── (MCP) ──► [ AI Agent Engine ] ◄── (ACP) ──► [ Developer IDE ]
(Databases, GitHub, Slack)             (Devin / Claude Code)             (VS Code / IntelliJ)

• MCP (Model Context Protocol): Governs how the agent connects downward to external tools, databases, and APIs.
• ACP (Agent Client Protocol): Governs how the agent connects upward to developer IDEs, terminals, and editor UI interfaces.

Industry Adoption: Cognition, JetBrains, GitHub, Google

![ACP Implementation Timeline](/uploads/content/news/agent-client-protocol-acp-multi-agent-ide-2026/acp-timeline.webp "ACP Adoption and Implementation Timeline")

The ACP specification has gained immediate backing across major enterprise tooling vendors:

• Cognition (Devin Desktop): Uses ACP as the native communication bus for Devin Desktop local tasks.
• JetBrains: Shipped native ACP support across all 2026.2 IDE releases (IntelliJ, PyCharm, WebStorm, Rider).
• Google: Integrated ACP into Antigravity IDE and Cloud Workstations.
• VS Code & GitHub: Available via official open-source ACP client extensions.

Comparison: Proprietary IDE Lock-In vs. Open ACP Standard

FAQ

About the Author

Conclusion

The Agent Client Protocol (ACP) marks the end of isolated AI coding silos. By establishing a universal JSON-RPC contract between editors and agents, ACP gives developers total freedom over their choice of model, agent framework, and development environment.

For related insights, explore our architectural guides on Model Context Protocol (MCP) 1.0 foundations and Cursor hooks & grind loop control planes.

Vatsal Shah

Technical Project Manager & Solution Architect

I write code, ship agentic systems, and advise boards from India and global HQ — 15+ years across BFSI, GCC, and Fortune-scale cloud programs. If you need architecture that survives audit, start here.

View credentials →