ACP Spec 1.0: Build Your AI Agent Once, Run It in Every IDE

In August 2025, Zed Industries published a draft protocol for agent interoperability and called it ACP — the Agent Client Protocol. For most of the following ten months it lived in preview, usable but provisional. This week, under a new open governance model backed by Zed, JetBrains, GitHub, Google, and Cognition, ACP Spec 1.0 is the first stable release — frozen, versioned, and safe to build against. The O(n×m) integration problem that made multi-agent setups a mess is now somebody else's concern.

If you run Claude Code alongside Codex, Devin Local, or OpenCode — and you are re-reading the same files in every agent session — this is the fix. ACP defines a standard wire protocol so that each agent you register runs as a first-class peer in any compatible editor, sharing a unified context layer and appearing in the same command surface. No custom glue. No redundant file reads.

The O(n×m) problem that ACP solves

Before the Language Server Protocol, every editor had to implement every language separately. Writing Go support for Vim meant writing it again for Emacs, then again for VS Code. The combinatorial cost was why most editors only supported a handful of languages well. LSP collapsed that to O(n+m): each editor implements the protocol once; each language server implements it once.

AI coding agents have the same problem. Claude Code has integrations with Devin Desktop and Zed. Codex has different integrations with different editors. Devin Local has its own. When you want to run Claude Code alongside Devin Local in the same project — routing high-stakes work to Opus 4.8 and fast drafts to Devin Local — you either live in two windows or build custom glue. Neither scales.

ACP applies the LSP fix. Each agent implements the protocol once and runs anywhere. Each editor implements it once and hosts everything. The 25+ agents at ACP 1.0 launch cover the full range: reasoning models (Claude Code / Opus 4.8), speed-optimized local agents (Devin Local), open-source terminal agents (OpenCode, Aider), and enterprise-controlled agents (Codex on Bedrock, Copilot agent mode).

What is in ACP Spec 1.0

ACP is JSON-RPC 2.0 over stdin/stdout. The editor launches the agent as a subprocess and exchanges protocol messages bidirectionally. The spec defines four primitive operations:

• dispatch — editor sends a task to the agent with an optional skill loadout, file list, and Spaces context ID.
• observe — agent streams incremental output (thoughts, tool calls, diffs) back to the editor in real time.
• interrupt — editor pauses or aborts an in-flight session cleanly without killing the subprocess.
• collect — editor retrieves the final structured output (diff, report, or JSON artifact) from a completed session.

Spec 1.0 adds three things that were missing from the preview: typed error codes (so editors can display actionable failures instead of "agent error"), a capability negotiation handshake (agents declare what they support at registration time), and a formalized Spaces context schema so any editor can expose shared context to any agent without proprietary extensions.

{
  "method": "acp/initialize",
  "params": {
    "agent": "claude-code",
    "version": "2.x",
    "capabilities": {
      "skills": true,
      "spacesContext": true,
      "subagents": true,
      "streaming": true
    },
    "defaultSkills": ["code-review", "unit-test"]
  }
}

The capability handshake means editors no longer guess what an agent supports. If an agent declares "subagents": false, the editor disables subagent dispatch for that session. If it declares "spacesContext": true, the editor hydrates the session with the current Space's task history before the first dispatch.

Compatible agents and editors

ACP 1.0 ships with 25+ compatible agents. The ones most relevant to a typical engineering team:

| Agent              | Vendor       | Best for                        |
|--------------------|--------------|----------------------------------|
| Claude Code (Opus) | Anthropic    | High-stakes reasoning, review    |
| Claude Code (Sonnet)| Anthropic   | Balanced speed + quality         |
| Devin Local        | Cognition    | Fast general coding, test gen    |
| Codex CLI          | OpenAI       | OpenAI API, AWS Bedrock accounts |
| OpenCode           | Community    | Self-hosted, multi-provider      |
| Copilot agent mode | GitHub       | GitHub-native workflows          |
| Aider              | Community    | Git-integrated, OSS teams        |

On the editor side: Devin Desktop (native, first-class), Zed (built the spec, shipping 1.0 alongside), JetBrains IDEs (IntelliJ, GoLand, PyCharm), VS Code via the acp-bridge extension, and GitHub Codespaces (ACP in the browser environment). Claude Code itself does not yet surface an ACP command center, but Claude Agent — the ACP shim published by Anthropic — lets Claude Code register as a peer inside any of these editors.

Configure ACP in 20 minutes

The setup is three steps: install the shim for each agent you want to use, register each one with your editor, and configure the .devin/agents.json (or the equivalent .zed/agents.json in Zed) to set default skills and context sharing.

# Claude Code ACP shim (Anthropic-published)
npm install -g @anthropic-ai/claude-agent-acp

# Codex ACP mode (built into @openai/codex 0.3+)
npm install -g @openai/codex   # already ACP-native if >=0.3

# OpenCode (already ACP-native)
npm install -g opencode  # check: opencode --version | grep acp

# In Devin Desktop
devin agent add claude-opus \
  --command "claude-agent-acp" \
  --args "--model claude-opus-4-8" \
  --skills code-review,security-audit

devin agent add claude-sonnet \
  --command "claude-agent-acp" \
  --args "--model claude-sonnet-4-6" \
  --skills unit-test,docs

devin agent add codex \
  --command "npx @openai/codex --acp" \
  --skills build,deploy

# Verify
devin agent list

{
  "version": "1.0",
  "defaultAgent": "devin-local",
  "spacesContext": true,
  "agents": [
    {
      "id": "devin-local",
      "protocol": "acp",
      "command": "devin-local",
      "args": ["--acp"],
      "spaceContext": true,
      "skills": []
    },
    {
      "id": "claude-opus",
      "protocol": "acp",
      "command": "claude-agent-acp",
      "args": ["--model", "claude-opus-4-8"],
      "spaceContext": true,
      "skills": ["code-review", "security-audit"]
    },
    {
      "id": "claude-sonnet",
      "protocol": "acp",
      "command": "claude-agent-acp",
      "args": ["--model", "claude-sonnet-4-6"],
      "spaceContext": true,
      "skills": ["unit-test", "docs"]
    },
    {
      "id": "codex",
      "protocol": "acp",
      "command": "npx",
      "args": ["@openai/codex", "--acp"],
      "spaceContext": true,
      "skills": ["build"]
    }
  ]
}

Once registered, dispatch from the Agent Command Center (Devin Desktop) or from the command palette in Zed. The --agent flag on the CLI lets you target a specific agent without switching windows:

# Dispatch to Opus for a high-stakes review
devin run --agent claude-opus "Security audit the auth module — OWASP Top 10"

# Fast test generation with Devin Local + skills
devin run --agent devin-local --skills unit-test "Write tests for src/billing/*"

# Parallel dispatch (fan-out, both agents get the task)
devin run --agents devin-local,claude-sonnet \
  "Devin Local: write tests. Claude Sonnet: write inline docs. Same auth module."

SKILL.md files inside ACP sessions

ACP does not change how SKILL.md files work — it extends where they run. A skill installed via npx @skills-hub-ai/cli install code-review is a local file. When Claude Agent ACP registers it at the skills key in agents.json, the ACP host passes the skill content to Claude Code at dispatch time the same way a direct invocation would.

What changes is context richness. A skill running inside an ACP session with Spaces enabled has access to the task history and file-read cache from other agents that ran earlier in the same Space. A code review skill that previously had to re-read every file the implementer touched now receives that file list from the Spaces context layer. The model context window fills with code under review, not boilerplate re-hydration.

For teams publishing skills to skills-hub.ai: skills that declare platforms: [CLAUDE_CODE] work in ACP sessions out of the box. There is no new platform tag required. The ACP layer is transparent to the skill itself.

ACP registry and the road ahead

The governance document published alongside Spec 1.0 commits to three things: a breaking-change guarantee (no non-backward-compatible changes without a major version bump and a 12-month deprecation window), a public conformance test suite (so any team can verify their agent or editor is compliant), and a public ACP agent registry.

The registry is the interesting piece. Cognition announced it in June 4 alongside the Devin Desktop launch, describing it as "analogous to what skills-hub.ai does for SKILL.md files — where any team can publish a compliant ACP agent definition that users can install with a single command." Spec 1.0 formalizes the agent definition format that the registry will use, which means the registry can ship without further breaking changes to the schema.

For now, the practical step is registration. If your team uses more than one AI coding agent today — even if just Claude Code and Copilot — setting up ACP takes 20 minutes and eliminates the context duplication cost immediately. The skill for it is on skills-hub.ai if you want an automated setup:

# Install the ACP setup skill and run it
npx @skills-hub-ai/cli install acp-agent-setup

# In Claude Code
/acp-agent-setup

Related reading: the June 4 Devin Desktop launch post for the full ACP backstory, the MCP 2026 stateless upgrade for the companion protocol, and the integration skills catalog for ready-to-install agent setup skills.