Windsurf Is Now Devin Desktop: ACP, Devin Local, and What the Rebrand Actually Changes

On June 2, 2026, Cognition shipped a routine over-the-air update to every Windsurf installation. When it landed, the application had a new name, a new icon, and a fundamentally different default screen. Windsurf is now Devin Desktop. But this is not a rebrand. The name change is the least interesting part of what shipped.

Two things matter: the Agent Client Protocol (ACP), an open standard that lets any compatible agent run inside any compatible editor, and Devin Local, a complete Rust rewrite of Cascade that is 30% more token efficient and ships with native subagent support. Together they make Devin Desktop the first IDE where Claude Code, Codex, and Devin run side-by-side in a unified command center — not as tabs, but as first-class peers sharing the same context layer.

What actually changed

Windsurf was an editor with AI bolted on. The primary surface was a code editor; the agent lived in a sidebar panel. Devin Desktop inverts that. Open the app and the first screen is the Agent Command Center: a Kanban board of every agent session currently running, sorted by status — in progress, blocked, ready for review. The editor is secondary.

This is not a cosmetic preference. It reflects Cognition's explicit bet that most developers in 2026 are not editing files manually; they are dispatching agents to do that and then reviewing the diffs. The Kanban surface is the right metaphor for that workflow. The traditional editor view is still there — press Cmd+E — but the product no longer pretends it is the main thing.

Agent Client Protocol — the LSP for agents

The most consequential thing in this release is not the Rust rewrite or the new UI. It is ACP. The Agent Client Protocol is an open standard created by Zed Industries in August 2025 and now backed by JetBrains, Google, GitHub, Cognition, and over 25 agents at launch. The analogy Cognition uses is deliberate: ACP is the Language Server Protocol for AI coding agents.

LSP solved a O(n×m) integration problem: before LSP, every editor had to implement language support for every language separately. After LSP, editors implement one protocol; languages implement one protocol; everything interoperates. ACP does the same for agents and editors. An agent implements ACP once and runs in any ACP-compatible editor. An editor implements ACP once and hosts any ACP-compatible agent.

Technically, ACP operates via JSON-RPC 2.0 over stdin/stdout. The editor launches the agent as a subprocess and exchanges protocol messages bidirectionally. Agents can declare the MCP servers they need, and the editor provisions them. Sessions expose a standard interface: dispatch, interrupt, observe, and collect output.

{
  "agents": [
    {
      "id": "claude-agent",
      "protocol": "acp",
      "command": "claude",
      "args": ["--acp"],
      "skills": ["code-review", "unit-test"],
      "spaceContext": true
    },
    {
      "id": "codex-agent",
      "protocol": "acp",
      "command": "npx",
      "args": ["@openai/codex", "--acp"],
      "spaceContext": true
    },
    {
      "id": "devin-local",
      "protocol": "acp",
      "command": "devin-local",
      "args": ["--acp"],
      "spaceContext": true
    }
  ]
}

With this configuration all three agents appear in the Agent Command Center as peers. You dispatch tasks to any of them; their sessions share the Spaces context layer, so Codex picks up where Claude Code left off without re-reading the same files.

Devin Local: Cascade rewritten in Rust

Cascade — Windsurf's original local agent — has been retired. Its successor, Devin Local, is a complete rewrite in Rust. Cognition's stated goals were two: token efficiency and modern agent capabilities. Both land in this release.

The 30% token efficiency improvement is a structural result of the Rust rewrite. Cascade accumulated technical debt in how it serialized context windows — redundant file content, repeated system prompts, cumulative tool-call history that was never pruned. The new binary manages context as a structured DAG and prunes aggressively, passing only the delta each turn needs.

Feature parity with Cascade is complete. Subagents — which Cascade added in Windsurf 2.0 — are supported in Devin Local with tighter isolation guarantees. Each Devin Local subagent runs in its own process with its own ACP session, which means the parent can monitor child agents in the Kanban view just like any other session.

Running Claude Code inside Devin Desktop

Claude Agent — the ACP-mode shim for Claude Code — is one of the Day 1 ACP integrations. Enable it once and Claude Code sessions appear in the Agent Command Center alongside Devin sessions. The practical implication: you can run Claude Code as a specialist inside Devin Desktop for tasks where Opus 4.8's reasoning quality matters, and Devin Local for faster, cheaper general work — all from a single interface.

# Install the ACP shim (first time only)
npm install -g @anthropic-ai/claude-agent-acp

# Register with Devin Desktop
devin agent add claude-agent \
  --command "claude-agent-acp" \
  --skills code-review,unit-test,security-audit

# Launch a session
devin agent run claude-agent "Refactor auth module for OAuth 2.1"

Skills from skills-hub.ai load into Claude Agent sessions exactly as they would in a standalone Claude Code session. The --skills flag at registration is the default loadout; individual tasks can override it with --skills at dispatch time.

Skills, Spaces, and shared context

The combination of ACP and Spaces solves one of the most annoying problems in multi-agent workflows: context re-hydration. Before ACP, if you switched from Devin to Claude Code mid-task, Claude Code had to re-read every file Devin had already processed. With Spaces providing a shared context layer across ACP sessions, each new agent inherits the session graph — files already read, tools already called, diffs already staged.

From the SKILL.md perspective, nothing changes for existing skills. Claude Code loads them via the skills: directive in the agent definition file, as before. But when that skill runs inside an ACP session in Devin Desktop, it has access to Spaces context that a standalone Claude Code session does not — specifically, the task history and file-read cache from other agents that ran earlier in the same Space.

Your Windsurf is already Devin Desktop

There is no migration. Cognition shipped this as a standard OTA update to all existing Windsurf installations. Plans, pricing, extensions, and settings carry over unchanged. The ~/.windsurf configuration directory is read as an alias for ~/.devin until the July 1 cleanup release.

The only manual step is enabling ACP agents. Devin Local runs automatically as the default agent — no configuration needed. To add Claude Agent or Codex, run the devin agent add command shown above, or use the Settings → Agents panel in the IDE.

# Check your Devin Desktop version
devin --version
# Should print: Devin Desktop 1.0.0 (formerly Windsurf 2.x)

# List registered agents
devin agent list
# Devin Local  acp  running  v1.0.0 (Rust)
# Cascade       acp  deprecated  (removed 2026-07-01)

What's next

Cognition's roadmap points at two things. First, a Devin Cloud ↔ Devin Desktop handoff via ACP: tasks that exhaust the local agent's context or compute budget will be seamlessly handed to the cloud tier, which already runs Devin Cloud sessions. The local and cloud agents will share a Space so the handoff is invisible to the developer.

Second, a public ACP registry — analogous to what skills-hub.ai does for SKILL.md files — where any team can publish a compliant ACP agent definition that Devin Desktop users can install with a single command. Cognition has committed to publishing the ACP spec under an open governance model, with the first spec release expected in late June.

For now, the actionable step is simple: update Devin Desktop (it already happened via OTA), then add Claude Agent if you use Claude Code. Run your first multi-agent session — dispatch a task to Claude Code for the high-reasoning implementation work and Devin Local for the test generation. Watch how Spaces prevents them from duplicating file reads. It is the cleanest multi-agent UX in any IDE right now.

# Add Claude Agent (one-time setup)
npm install -g @anthropic-ai/claude-agent-acp
devin agent add claude-agent --command "claude-agent-acp" --skills code-review

# Run a parallel two-agent task
devin run --agents devin-local,claude-agent \
  "Implement the user auth refactor; Devin Local writes tests, Claude Agent reviews"

# Watch both sessions live in the Agent Command Center
devin tui

Skills for ACP-based multi-agent workflows — including an acp-multi-agent skill that automates agent registration and Spaces setup — are available now on skills-hub.ai/browse.