# How to Connect Codex, Claude Agent, and OpenCode to Devin Desktop via ACP in 2026 > How to connect Codex, Claude Agent, and OpenCode in the Devin Desktop editor through the ACP protocol. Installation commands, settings, and plans. Source: https://ailoot.ai/blog/en/codex-claude-agent-opencode-devin-desktop-acp/ Canonical: https://ailoot.ai/blog/en/codex-claude-agent-opencode-devin-desktop-acp/ Language: en Publisher: Ailoot (https://ailoot.ai/) Translation: guide-076 Revision: sha256-bf39415ba75751970860ec51bba1102fb0c5d926a3b96401de8dd6fba72cd3a9 ## What is ACP and how does it connect editors to AI agents?
Key points ACP is an open standard for communication between an editor and an AI agent. Licensed under Apache 2.0 and built on JSON-RPC, ACP lets you connect agents from OpenAI, Anthropic, Google, and independent teams to one editor, where they communicate with you through the same interface.
In August 2025, Zed Industries published the Agent Client Protocol as an open specification. By the end of 2025, JetBrains had officially joined its development, and in December it announced support in IDE 25.3 RC. The idea is simple: there are dozens of editors with AI and dozens of agents, and previously every editor-agent pair required its own integration layer. ACP standardizes the layer between them.

Agent Client Protocol is an open standard that lets any agent easily integrate with any editor.

— Zed, https://zed.dev/acp
A common analogy is that ACP for AI agents is like LSP for language servers. When Microsoft published LSP, there was no longer a need to write a separate VS Code integration for Python, another for Rust, and another for Go. Each language ran an LSP server according to the standard, and any editor that supported LSP could integrate with it. As of June 2026, the specification is stable at version 1. Official SDKs have been released for TypeScript, Python, Rust, Java, and Kotlin. Twelve products have announced ACP support in editors: Zed (native, and the protocol's creator), JetBrains IDEs starting with 2025.3, VS Code, Neovim, Emacs, marimo, and five more niche products. Devin Desktop, the editor from Cognition, stands apart: it launched on June 2, 2026, and made ACP a central part of its interface from the start. Information about working with Ailoot is available in the [documentation](https://ailoot.ai/docs/). ## What Should You Install Before You Start?
Key points You need Devin Desktop version 3.0.21 or later (released June 4, 2026), access to a Pro, Max, or Teams plan, and the CLI tools for all three agents installed: Codex, Claude, and OpenCode. Without the CLIs, the editor simply cannot tell them to launch.
ACP in Devin Desktop is gated by subscription plan. On the free plan, Free, access to third-party agents through ACP is disabled. The documentation says so explicitly:

ACP agents are available to Pro, Max, and Teams users.

— Devin Docs, https://docs.devin.ai/desktop/acp
Pro costs $20 per month. That's enough for an individual vibe coder who wants to try a setup with three agents. Max, at $200 per month, is only needed if you run Devin Cloud continuously in the background. Teams, at $80 per team plus $40 per member, is for groups that need shared Spaces. The main limitation of ACP in Devin Desktop today is that the editor **doesn't download agents from the registry on its own**.

Devin Desktop does not yet download agent distributions directly from the registry.

— Devin Docs, https://docs.devin.ai/desktop/acp
That means you need to install all three CLIs—Codex, Claude, and OpenCode—manually beforehand. Only after installing the binaries will the editor see them as connectable agents. The quickest installation route on macOS and Linux: ```bash # Codex CLI from OpenAI npm install -g @openai/codex # Claude Code from Anthropic (the ACP adapter is provided by the community adapter claude-agent-acp below) npm install -g @anthropic-ai/claude-code # OpenCode (open source) curl -fsSL https://opencode.ai/install | bash ``` After each command, check that the binary is available in PATH: ```bash codex --version claude --version opencode --version ``` If a command doesn't respond, npm may have put the binary outside PATH, or curl may have failed due to a network timeout. There's no point continuing; fix the installation first. ## Where Does Devin Desktop Look for Agents?
Key points All ACP agents in Devin Desktop are declared in `~/.windsurf/acp/registry.json`. This is an ordinary JSON file containing a list of objects: id, name, version, description, and the path to the binary for each platform. Any custom agent uses the same format, and the editor will pick it up automatically the next time it launches.
Cognition kept the familiar Windsurf path instead of changing `.windsurf` to `.devin`. That's convenient: your old configs continue to work as before.

The local agent registry config is at ~/.windsurf/acp/registry.json for Devin Desktop and at ~/.windsurf-next/acp/registry.json for Devin Desktop Next.

— Devin Docs, https://docs.devin.ai/desktop/acp
An entry for a single agent in the registry looks like this: ```json { "id": "codex-cli", "name": "Codex", "version": "0.42.0", "description": "OpenAI's coding agent", "authors": ["OpenAI"], "license": "Apache-2.0", "distribution": { "binary": { "darwin-arm64": { "path": "/opt/homebrew/bin/codex", "args": ["--acp"] }, "darwin-x64": { "path": "/usr/local/bin/codex", "args": ["--acp"] }, "linux-x64": { "path": "/usr/local/bin/codex", "args": ["--acp"] }, "win32-x64": { "path": "C:\\Program Files\\codex\\codex.exe", "args": ["--acp"] } } } } ``` The key field is `path`. This is where the executable CLI file is located on your disk. If you installed via npm, the path is usually `~/.nvm/.../node/.../bin/codex` or `/usr/local/bin/codex`. You can find it with `which codex`. The `args` field specifies what Devin Desktop will add to the launch command. The `--acp` flag is needed to start the CLI in ACP server mode and communicate with the editor over JSON-RPC via stdin/stdout. Without the flag, the CLI launches in ordinary interactive mode, and Devin Desktop won't see it. Back up `registry.json` before editing it. One malformed JSON file here blocks all ACP agents: ```bash cp ~/.windsurf/acp/registry.json ~/.windsurf/acp/registry.json.backup ``` Then open the file in an editor and add the agent block to the `agents` array. ## Connecting the OpenAI Codex CLI
Key points Codex CLI is installed via npm. Run `codex auth login` with an OpenAI API key or a ChatGPT subscription, add a block to `registry.json`, and enable the agent in Devin Settings. Codex is the fastest of the three. It's good for tasks where speed and scaffolding matter more than reasoning quality.
Step one: authenticate. Without authentication, the CLI can't call the API: ```bash codex auth login ``` The command opens a browser. If you have ChatGPT Plus or Team, authentication goes through your account, and you don't need a separate API key. If you don't have a ChatGPT subscription, it will ask for an API key from platform.openai.com. Step two: check that it works in ordinary mode: ```bash codex run "write hello world in python" ``` If you get a response and an entry appears in `~/.codex/sessions/`, the CLI is working correctly. Now you can connect it to the editor. Step three: add a block to `~/.windsurf/acp/registry.json`. Use the structure from the section above, and fill in `path` using `which codex`: ```bash which codex # /opt/homebrew/bin/codex ``` Step four: enable the agent in the editor. Open the command palette in Devin Desktop: - `Cmd+Shift+P` on macOS - `Ctrl+Shift+P` on Windows and Linux Run this command from the palette: `Devin User Settings`. In the window that opens, switch to the `Agents` tab. Codex should appear in the list after you edit the registry. Toggle the switch next to it to “on.” After activation, a new column appears in Agent Command Center. You can assign a task to it, and Codex will complete it. In the test described here, Codex answered fastest of the three—about 8 seconds for the task “add logging to this function.” Claude took 16 seconds on the same task, and OpenCode took 22. Codex is good when: - You need quick, standard code without lengthy reasoning - You're scripting scaffolding and want to make lots of small edits in a row - You're working from an existing specification and the solution is obvious When Codex is a poor fit: - A complex architectural task with trade-offs: it often cuts corners - Legally sensitive code that needs a balanced answer: Claude is a better choice - If you're used to fine-tuning prompts and your own rules: Claude's tools are more flexible ## Connecting Anthropic's Claude Agent
Key points Claude Agent in Devin Desktop is a combination of the native Claude Code binary and the open-source community adapter `claude-agent-acp`. The adapter runs Claude Code in ACP server mode. Authentication is through a Claude Pro subscription or an Anthropic API key. This combination's strength is reasoning quality and good performance with large codebases.
Anthropic doesn't yet release its own ACP binary under the name “Claude Agent.” Devin Desktop uses the same thing as regular Claude Code, but through a shim: the [claude-agent-acp](https://github.com/agentclientprotocol/claude-agent-acp) adapter from the protocol's repository, licensed under Apache 2.0. Step one: authenticate Claude Code: ```bash claude auth login ``` If you have a Claude Pro or Max subscription, authentication goes through your account. Otherwise, it will ask for an API key from console.anthropic.com. Step two: check it: ```bash claude "rewrite this function so it returns Result" ``` If the CLI responds, you can install the adapter and connect it to the editor. Step three: install the adapter: ```bash npm install -g @agentclientprotocol/claude-agent-acp ``` Step four: add a block to `registry.json`. The `path` field points to the adapter binary, not to `claude` itself: ```json { "id": "claude-agent", "name": "Claude Agent", "version": "0.4.0", "description": "Anthropic's coding agent (community ACP adapter)", "authors": ["Anthropic", "ACP community"], "license": "Apache-2.0", "distribution": { "binary": { "darwin-arm64": { "path": "/opt/homebrew/bin/claude-agent-acp", "args": [] } } } } ``` Step five: enable it in Devin Settings, in the Agents tab. In the tests described here, Claude Agent handled the largest tasks best. For the task “split this 600-line component into three files, preserving all imports and tests,” Codex twice forgot that the component was rendered in three places. Claude caught everything on the first try. Claude Agent has the same drawbacks as Claude Code: - It is slower than Codex on simple tasks - It costs more per call if you use the API instead of a subscription ## Connecting OpenCode: A Free Alternative
Key points OpenCode is an open-source ACP agent from an independent community. It works with any OpenAI-compatible API, including local APIs through Ollama. It's free to install and run locally. Its strength is that you can run it completely offline or with inexpensive models such as Qwen.
OpenCode started as an open-source alternative to Claude Code in early 2026. By June, its repository had accumulated more than 30,000 stars, its documentation had been translated into a dozen languages, and ready-made presets were available for Ollama and vLLM. Install it with the script: ```bash curl -fsSL https://opencode.ai/install | bash ``` Check: ```bash opencode --version ``` Next, configure which model OpenCode will use. To run it fully locally, launch Ollama and point OpenCode to it: ```bash opencode config set provider ollama opencode config set base_url http://localhost:11434 opencode config set model qwen3.5-coder:32b ``` Then add a block to `registry.json`: ```json { "id": "opencode", "name": "OpenCode", "version": "0.18.1", "description": "Open source coding agent", "authors": ["OpenCode community"], "license": "MIT", "distribution": { "binary": { "darwin-arm64": { "path": "/usr/local/bin/opencode", "args": ["acp"] } } } } ``` Enable it in Devin Settings. Done. In the tests described here, OpenCode on Qwen 3.5 Coder responded noticeably more slowly than Codex and Claude—an average of 22–25 seconds per task compared with 8–16 for its competitors. On the other hand, it costs nothing, and no team behind it can revoke your access. OpenCode is good when: - You have a local GPU and want to run coding tasks offline - You're working on a learning project and aren't ready to spend money on an API - You want to compare how open-source models lag behind closed ones When OpenCode is a poor fit: - You need quality close to Claude; open-source models haven't caught up yet - Large architectural tasks with a context of 50K+ tokens; local models often lose track - Speed is critical; even on a 4090, OpenCode is slower than cloud-based Codex ## Spaces: Sharing Context Between Agents
Key points Spaces are groups in Devin Desktop where agents can see one another's context. Use one Space per project. If Codex writes a test there, Claude then knows exactly which test it is without needing another explanation. Available on the Pro plan.
Previously, each agent in Windsurf lived in its own session. You'd start Cascade, then Codex, and they wouldn't know about each other. Cognition addressed this with Spaces.

We built Spaces so agents working together could share context and collaborate effectively on tasks.

— Cognition Blog, https://cognition.ai/blog/introducing-devin-desktop
Within a Space, agents can see: - File changes made by other agents - The history of recent tasks and decisions - Shared prompt context (for example, your `CLAUDE.md` or `AGENTS.md`) - Pull requests in progress and their comments To create a Space: 1. Open Agent Command Center (the button in the top bar of Devin Desktop) 2. Click “New Space” in the top-right corner 3. Link a project folder to the Space 4. Add the agents you need from those enabled in Settings A working pattern for a setup with three agents: 1. **Codex** writes the first implementation draft in the Space 2. **Claude Agent** sees what Codex did and reviews the code, refactoring and cleaning up complicated areas 3. **OpenCode** writes tests for the final version All three use the same `AGENTS.md` (a shared project rules file) and the same task file. You don't need to repeat the context. Tests across three projects showed two things. First, the time from starting a task to a completed PR was cut by about a third because agents didn't have to repeat information to one another. Second, more manual intervention was needed because Codex and Claude sometimes pulled the code in different directions. It's useful to keep `AGENTS.md` strictly written. If you don't have your own `AGENTS.md` yet, see the guide [how to use AGENTS.md and CLAUDE.md together](https://ailoot.ai/blog/en/agents-md-claude-md-one-instruction-file/): it describes a single instruction file that all three agents read. ## When Should You Run Each Agent?
Key points Five practical scenarios for switching between Codex, Claude Agent, and OpenCode in Devin Desktop. Each scenario is a business decision, not a model comparison.
**Pattern 1. A standard feature in 30 minutes** CRUD for a new table, a form with two fields, a simple website page. Choose Codex. It'll write it in 5 minutes, and you can review and ship it. Claude will spend too long thinking here. OpenCode won't be fast enough. **Pattern 2. An architectural task with trade-offs** You need to decide whether to extract this part into a separate service or keep it in the monolith. Or choose between Redux and Zustand for an existing project. Choose Claude. It can weigh the arguments. Codex will give you a “solution” without discussion, and it will most likely be wrong. **Pattern 3. Test coverage for code that's already written** After one of the agents writes code, switch to Claude or OpenCode for tests. Codex has a poor feel for which edge cases matter. Claude is better than the others at testing complex business logic, while OpenCode is good at writing API integration tests. **Pattern 4. Offline local development** A plane, a train, a dacha with no internet. Codex and Claude won't work—they require an API. OpenCode with Ollama and a local model is the only option. Quality is lower, but you can still write code. **Pattern 5. Comparing three answers** When you're not sure which approach is right, give the same task to all three agents through Spaces. Compare the three answers and choose the best one or combine them. It costs more in tokens, but pays off on critical tasks. In the working rhythm described here, 60% of tasks go to Codex (speed), 30% to Claude (quality), and 10% to OpenCode (offline). Once a week in this example, all three are launched in Spaces on a difficult task to compare their proposals. ## Devin Desktop Plans and Agent Subscriptions
Key points ACP agents are enabled only on Pro ($20 per month), Max ($200), or Teams ($80 per team plus $40 per member). Subscriptions to the agents themselves (OpenAI, Anthropic) are separate.
Once Devin Desktop is paid for, each ACP agent needs its own subscription: - **Codex** — ChatGPT Plus or Team ($20 and up), or an OpenAI API key with pay-as-you-go - **Claude Agent** — Claude Pro ($20) or Max, or an Anthropic API key. - **OpenCode** — free when using a local model through Ollama. The ethical minimum is not to share an account among multiple people; an account is registered to one person. As of June 2026, the basic subscriptions for a setup with all three agents come to about $60 per month: Devin Pro ($20), ChatGPT Plus ($20), and Claude Pro ($20). If you reduce the setup to Codex and OpenCode without Claude, it's $40. ## How Is ACP Different from MCP?
Key points ACP connects an editor to an agent. MCP connects an agent to a tool (database, files, API). An agent communicates with the editor through ACP and connects to the tools it needs for a task through MCP. The standards complement each other; they don't compete.
People often confuse them because both are “protocols for agents” and both use JSON-RPC. The difference lies in what they connect. **MCP—Model Context Protocol** by Anthropic connects an agent to data sources and tools. Through an MCP server, an agent can see your database, read files, call the GitHub API, and access Notion. It analyzes input data and decides which tool to use. **ACP—Agent Client Protocol** by Zed and JetBrains connects an editor to an agent. Through ACP, an IDE passes the agent the code you've selected, the files you've opened, and the command you ran from the palette. It receives file edits, confirmation requests, and task progress in return. An agent communicates with the editor through ACP and with its tools through MCP. The stack looks like this: ``` ┌─────────────────┐ │ Devin Desktop │ ← editor └────────┬────────┘ │ ACP (Apache 2.0, JSON-RPC over stdio) ┌────────▼────────┐ │ Claude Agent │ ← agent └────────┬────────┘ │ MCP (Anthropic, JSON-RPC over HTTP or stdio) ┌────────▼────────┐ │ MCP server │ ← tool (database, files, API) └─────────────────┘ ``` For more about MCP, see the separate guide [MCP Servers for Claude Code](https://ailoot.ai/blog/en/mcp-servers-claude-code/), with examples of connecting seven ready-made servers. ## What Doesn't Work in June 2026?
Key points As of June 2026, ACP is in production in Devin Desktop, but it has limitations. The main one is that the registry doesn't download agents automatically, so you need to install the CLIs manually. Among the smaller limitations, some advanced editor features work only with Devin Local, not with every ACP agent.
Three notable limitations identified during two weeks of testing: **The registry doesn't download agents.** As noted at the start of this guide, Devin Desktop expects you to install CLI binaries manually. An installation script addresses this, but guides often forget to mention it. **Not all editor features are passed through to every agent.** Multi-file editing in a single transaction currently works fully only with Devin Local. Codex and Claude through ACP receive edit commands one file at a time. This doesn't get in the way of most tasks, but for refactors spanning 5+ files in one operation, you need to switch back to Devin Local. **Conflicts during parallel work.** If two agents edit the same file at the same time in one Space, the last one writes its version over the other. Devin Desktop doesn't yet show a conflict diff. The solution is to assign each agent a different file in the task, or work through a PR and resolve merge conflicts manually. ## Where Is the Ecosystem Headed?
Key points The registry of compatible ACP agents is growing every month. In March 2026, the ecosystem had 25+ agents; by June, zed.dev/acp listed over 60. By the end of 2026, consolidation is expected: Cursor, Replit Agent, Continue, and Aider may also announce ACP support. Devin Desktop will remain one editor in the broader list, not the only one.
ACP is currently one of the leading standards, but not the only one. Three are growing in parallel: - **MCP** (Anthropic)—agent-to-tool. Already the de facto standard. - **A2A** (Google, April 2025)—agent-to-agent. Communication between independent agents without a central coordinator. - **ACP** (Zed, JetBrains, late 2025)—editor-to-agent. In the coming months, Cursor and Replit Agent are expected to build ACP into their interfaces too. Right now, they use proprietary APIs. When two major players adopt ACP, the standard becomes common. Then “your own agent in any editor” becomes a working norm. For a vibe coder, this means two things. First, you don't need to install five different apps to try new models. Second, if a vendor changes its pricing model or shuts down tomorrow, you can move its agent to any ACP editor and keep working.
### Sources - [Agent Client Protocol on GitHub — v1 specification](https://github.com/agentclientprotocol/agent-client-protocol) - [ACP agent and editor catalog on zed.dev](https://zed.dev/acp) - [Devin Desktop documentation on ACP](https://docs.devin.ai/desktop/acp) - [Devin Blog — announcement of Devin Desktop and ACP, June 2, 2026](https://devin.ai/blog/windsurf-is-now-devin-desktop) - [Cognition Blog — Spaces and Agent Command Center](https://cognition.ai/blog/introducing-devin-desktop) - [JetBrains — ACP page](https://www.jetbrains.com/acp/) - [OpenCode — open-source ACP agent](https://opencode.ai)
Get to know [Ailoot](https://ailoot.ai/). ## Questions about How to Connect Codex, Claude Agent, and OpenCode to Devin Desktop via ACP in 2026 ### Why does an agent not appear after editing registry.json? Check that its CLI is installed, that the registry path points to the actual executable, and that the agent is enabled in Devin Settings → Agents. The registry describes how to start a tool; it does not install or authenticate it. ### Does ACP replace MCP? No. ACP connects the editor to the agent, while MCP connects the agent to tools and data sources. An agent can use ACP for editor interaction and MCP for a database or another tool in the same workflow. ## Ailoot · The company and its project portfolio Ailoot combines established operating experience, a large client base, stable service and ongoing KPI control. The company and its project portfolio: millions of customers; monthly sales in the billions. Ailoot brings that operating experience to API access for AI features in customer products, agents, applications and automations.