Devin Desktop (Formerly Windsurf): What It Is, What Changed, and Pricing

TL;DR

Cognition shipped a rebrand, not a rewrite. Devin Desktop keeps the full Windsurf IDE but flips the default surface to an Agent Command Center — a Kanban board of every agent you’re running. Devin Local (the Rust-based Cascade replacement) is roughly 30% more token-efficient and supports subagents; it fully replaced Cascade at the July 1 cutoff. The biggest practical change is ACP support, which lets you run Claude Agent, Codex, or OpenCode inside the same shell. Pricing stays the same. Migration is automatic. The product is solid; the governance story is messy.

The $2.65 Billion Backstory in 90 Seconds

You can’t review Devin Desktop without the context. Windsurf was about to be acquired by OpenAI for $3 billion. That fell apart over IP tensions with Microsoft. Google DeepMind then hired Windsurf’s CEO Varun Mohan, co-founder Douglas Chen, and several key engineers in a deal reportedly worth $2.4 billion. Cognition picked up the remaining entity for roughly $250 million.

In short: the people who built Windsurf are at Google. The people shipping Devin Desktop are Cognition’s team, working with the codebase those founders left behind.

The update landed for Windsurf users on June 2. This review looks at what changed for anyone who used Windsurf next to tools like Cursor and Claude Code: the agent-first layout, Devin Local, and Spaces.

What the Update Actually Does

The over-the-air update on June 2 changed three things and kept everything else:

Changed:

• The app name, icon, and branding (Windsurf → Devin)
• The default landing view (editor canvas → Agent Command Center)
• The local agent engine (Cascade → Devin Local, with a July 1 cutoff)

Unchanged:

• All extensions, keybindings, LSPs, and workflows
• Your plan and pricing
• .windsurfrules files (still read alongside the new .devin/ format)
• File paths under ~/.windsurf/ (readable during transition; new writes go to ~/.devin/)

If you didn’t look at the icon in your dock, you might not notice the rebrand for a few days. Cognition couldn’t afford to break anything for the 1 million+ developers who had Windsurf installed.

The Agent Command Center

Open Devin Desktop and the first thing on screen is a Kanban board.

Every agent session, local and cloud, gets a card. Cards sort by status: in progress, blocked, ready for review. You can run one agent refactoring an API, another writing unit tests, and a third prototyping UI components, all visible in one view. Click a card to jump into that agent’s session with the full IDE context.

The editor is still there. You can switch to it with a single click, and it’s the same VS Code fork that Windsurf always was. But the Kanban-first default reframes the product: this is an agent management hub that happens to contain an IDE.

The Command Center is built for the morning check-in: see where overnight cloud sessions landed. For active coding, the editor view is still where most of the time goes. The Command Center works best when you’re running multiple agents in parallel on different tasks, a workflow that the Pro plan ($20/mo) supports but that most solo developers won’t hit often enough to justify the context-switching overhead.

Devin Local: The Cascade Replacement

Devin Local is a ground-up Rust rewrite of Cascade that Cognition claims is up to 30% more token-efficient on the same tasks. Cascade stays available through July 1, so the two can be compared side by side. What changes:

Token efficiency: on a medium-sized refactoring task (renaming a module, updating imports across 14 files, fixing tests), Devin Local used roughly 18,000 tokens where Cascade burned through about 24,000. That tracks with the 30% claim, at least for edit-heavy workflows. Generation-from-scratch tasks showed a smaller gap.

Subagent support: Devin Local can spin up helper agents for subtasks. Ask it to “refactor the auth module and update the tests,” and it’ll sometimes split that into two parallel sub-sessions rather than working sequentially. It doesn’t do this reliably yet, maybe 40% of the time on multi-step tasks. But when it fires, the wall-clock time drops noticeably.

Speed: SWE-1.6, Cognition’s own coding model, runs at 950 tokens per second and is included free on paid plans. It scores about 11% higher than SWE-1.5 on SWE-Bench Pro. You can also swap in Claude, GPT, or Gemini from the model picker.

What’s worse: it’s a new agent with new quirks, and whatever you’d learned about Cascade’s habits resets. Don’t assume it ran your tests after a refactor; check. The behavior is still settling.

The July 1 Deadline

Cascade shuts off on July 1, 2026. There’s no opt-out, no extended support window. If your CI pipelines or automation scripts invoke Cascade explicitly, you have less than a month to migrate them to Devin Local. The API surface is mostly compatible, but the agent name changed, and subagent-related callbacks work differently.

For individual developers using the IDE normally, this is invisible. The update already defaults to Devin Local. Teams with custom tooling built around Cascade had to move to Devin Local before the July 1 cutoff.

ACP Support: The Biggest Practical Change

The Agent Client Protocol (ACP) is an open-source protocol originated by Zed Industries in August 2025 and now adopted by JetBrains, Google, GitHub, and 25+ agent implementations. It’s a JSON-RPC 2.0 protocol over stdin/stdout. The editor launches an agent as a subprocess, and they talk bidirectionally from there.

Devin Desktop ships with ACP support out of the box. At launch, you can run:

• Codex (OpenAI) — OpenAI’s coding agent
• Claude Agent (Anthropic) — Anthropic’s agent runtime
• OpenCode — open-source agent
• Any custom ACP-compatible agent your team builds

You can run Claude Agent inside Devin Desktop on one task and Devin Local on another, and both appear as cards in the Agent Command Center. Shared context through Spaces (more on that below) lets one agent’s findings reach the other without copy-pasting.

Here’s a minimal ACP agent configuration in .devin/agents.json:

{
  "agents": [
    {
      "name": "claude-agent",
      "command": "claude-agent",
      "args": ["--stdio"],
      "protocol": "acp",
      "mcpServers": ["filesystem", "git"]
    }
  ]
}

The session/new handshake lets you declare associated MCP servers, so the agent inherits your project’s tool configuration without additional setup.

Whether ACP will win the agent-editor protocol war is still an open question. Cursor has its own internal protocol. VS Code’s extensions API covers some of the same ground. But with JetBrains and Google on board, ACP has enough momentum that supporting it is the right move for Cognition regardless.

Spaces: Shared Context Across Agents

Spaces group related sessions, PRs, files, and context objects into a shared layer. When two agents work within the same Space, they can access each other’s context without you manually bridging the gap.

The pitch is multi-agent workflows: one agent reviews code, another writes tests for the same PR, both pulling from the same Space. The simpler everyday use is keeping project context organized: one Space per project, so switching projects doesn’t mean reconfiguring context each time.

Spaces feel half-finished. You can’t template them, you can’t share them across team members on the Teams plan (yet), and there’s no API for creating them programmatically. Cognition’s roadmap probably has all of this, but today it’s a manual grouping feature.

Pricing: Nothing Changed (For Now)

Current tiers as of June 2026:

Devin’s consumption model uses ACUs (Agentic Computing Units), a normalized measure of VM time, model inference, and bandwidth. The Pro plan includes a baseline allocation; Teams gets $40/month of ACU usage per seat across all Devin products.

Pricing didn’t change in the rebrand, but the Max tier ($200/mo) is new. It sits between Pro and Teams, targeting power users who want extended cloud agent sessions without paying the per-seat overhead of a Teams plan. At 10x the price of Pro, it’s only worth it if you’re running cloud agents daily.

For comparison: Cursor Pro is $20/mo. Claude Code runs on API credits (roughly $5-30/mo depending on usage). Google Jules is $20/mo. Devin Pro at $20/mo is competitive on the surface, but heavy agent users will hit ACU limits and need Max or Teams.

What’s Good

The migration was invisible. Settings, extensions, keybindings all carried over without intervention. .windsurfrules files still work alongside the new .devin/ format, and file paths under ~/.windsurf/ are still readable.

Devin Local is measurably better than Cascade. The Rust rewrite delivers on the token efficiency promise, and the subagent capability, even at 40% reliability, hints at full task parallelism down the road. Watching an agent spin up a helper to run tests while it continues refactoring is satisfying when it works.

ACP support is the right strategic call. Being agent-agnostic turns the IDE into a neutral surface for any agent. Letting users bring Claude or Codex into the same environment is something most competitors haven’t done yet.

What’s Bad

The acquisition story creates real trust risk. The founders and CEO left for Google, and Cognition picked up the product for $250M after OpenAI and Google valued the team at $2.4-3B. Developers build muscle memory around their IDE, and that relationship depends on long-term stability that Cognition hasn’t established yet.

Spaces are undercooked. No templates, no team sharing, no programmatic creation. The feature shipped to give the Command Center a grouping mechanism; Spaces themselves aren’t ready for real multi-agent workflows.

The agent-first framing is premature for most users. Opening to a Kanban board instead of a code editor is a bold choice, but for most developers the day is still mostly editing, with agent interaction as the smaller slice. For solo developers, the Command Center is a distraction that takes a click to dismiss. Cognition could’ve made it opt-in.

Cascade’s July 1 deadline is aggressive. Four weeks from announcement to deprecation for a local agent that people built automation on top of. Teams with custom tooling are scrambling.

Who Should Use Devin Desktop

Move to it if: You were already on Windsurf, you run multiple agents in parallel, you want ACP support for third-party agents, or you want Devin Local’s subagent capability. You don’t have a choice about the rebrand (it already happened), but the underlying product improved.

Stay on Cursor if: You primarily use a single AI agent and care about tight editor integration with one model. Cursor’s agent mode and multi-file editing are more polished for the single-agent workflow. My OpenCode vs Claude Code vs Cursor comparison covers the core editor experience.

Consider Claude Code if: You work in the terminal, want direct model access without IDE overhead, and don’t need the visual agent management layer. Claude Code’s hooks system and subagent architecture give you similar multi-agent capability without the GUI.

FAQ

What happened to Windsurf?

Windsurf became Devin Desktop on June 2, 2026. Cognition acquired Windsurf’s product and brand after Google hired the founding team. The IDE is the same VS Code fork with the same extensions and settings, but the default interface now opens on an Agent Command Center instead of the editor.

Is Devin Desktop free?

There’s a free tier with limited Devin Local access and no cloud agents. The Pro plan is $20/mo with unlimited local agents and limited cloud sessions. Teams is $80/mo plus $40 per seat.

What is Devin Local?

Devin Local is a Rust rewrite of Cascade, Windsurf’s original local agent. It’s about 30% more token-efficient and supports subagents, meaning it can spin up helper agents for subtasks. Cascade is available through July 1, 2026, then it’s removed.

How do I migrate from Windsurf to Devin Desktop?

You don’t. The migration is automatic, delivered as a standard over-the-air update. Settings, extensions, keybindings, and workflows port automatically. .windsurfrules files continue working alongside .devin/ rules. File paths under ~/.windsurf/ are still readable. The only action item is migrating any CI/automation that explicitly invokes Cascade to Devin Local before July 1.

Is Devin Desktop better than Cursor?

They’re aiming at different things. Devin Desktop positions itself as an agent management hub with an IDE inside. Cursor builds agent features into its editor more tightly. If you run multiple agents in parallel and want ACP support, Devin Desktop is ahead. If you want the best single-agent editing experience, Cursor is still stronger.

Sources

• Windsurf is now Devin Desktop — official announcement — Cognition’s rebrand announcement with feature details
• Devin Desktop FAQ — official docs — migration details, pricing, Cascade EOL timeline
• SWE-1.6 preview and research update — Cognition’s coding model benchmarks
• Cognition agrees to buy what’s left of Windsurf — TechCrunch — acquisition backstory and financials
• Agent Client Protocol overview — ChatForest — ACP technical details and migration guide

Bottom Line

If you’re already on Windsurf, you’re on Devin Desktop whether you like it or not. The product got better in the transition, mostly because Devin Local earns the 30% efficiency claim and ACP opens the door to running any agent inside one IDE. The real test comes over the next two quarters: can Cognition ship at the pace Windsurf’s founders did, now that those founders are at Google?