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, but Cascade dies on July 1. 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.

I’ve been using Windsurf on and off since early 2026 alongside Cursor and Claude Code. When the update landed on June 2, I let it install and spent a week using the new version as my secondary IDE on a Python API project.

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.

In practice, I found myself checking the Command Center first thing in the morning to see where my overnight cloud sessions had landed. For active coding, I still spent 90% of my time in the editor view. 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.

1M+
Developers on the platform
30%
Token efficiency gain (Devin Local)
July 1
Cascade end-of-life
$20/mo
Pro plan (unchanged)

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. After a week of side-by-side testing (Cascade is still available through July 1), here’s what I noticed:

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. When I used Claude Opus 4.7 through Devin Local, the experience felt comparable to using it in Claude Code directly. The routing layer didn’t add perceptible latency.

What’s worse: Cascade had quirks, but I’d learned them. Devin Local has different quirks. It loops less than Cascade (good), but it also sometimes skips validation steps that Cascade would’ve caught, like running tests after a refactor. 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. But teams with custom tooling should test now, not on June 30.

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

I ran Claude Agent inside Devin Desktop on a debugging task alongside Devin Local on a feature branch, and both appeared as cards in the Agent Command Center. The shared context through Spaces (more on that below) meant I could hand off findings from one agent to another 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. In practice, I used it mostly to keep project context organized. My API project had one Space, my blog tooling had another, and switching between them was faster than 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 programatically. 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:

PlanPriceAgentsCloud Sessions
Free$0Limited Devin LocalNone
Pro$20/moUnlimited localLimited cloud
Max$200/moUnlimited localExtended cloud
Teams$40/seat ($80/mo min)Unlimited local + cloudTeam management
EnterpriseCustomEverythingVPC, SSO, SAML

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 my daily workflow is still 90% editing and 10% agent interaction. 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. The Cursor vs Claude Code vs Windsurf comparison still holds for 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

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?