Windsurf Is Now Devin Desktop and Cascade Is Deprecated

Windsurf became Devin Desktop on June 2, 2026, delivered as an over-the-air update to every existing Windsurf user. Plans, pricing, extensions, and settings carried over unchanged. But the underlying local agent, the default UI screen, and the protocol layer all changed substantially, and Cascade stops serving requests on July 1.

The rebrand closes a chapter that started in July 2025 when Cognition acquired Windsurf after Google hired away its founding research team. For nearly a year, Windsurf and Devin ran as parallel products inside the same company. Devin Desktop ends that separation and puts both under a single architecture built around the idea that the primary job of a coding environment is agent management, not file browsing.

What Is Devin Desktop and Who Already Has It

If you used Windsurf, you already have Devin Desktop. Cognition shipped the transition silently. Open the app and you will find the same editor, extensions, and keyboard shortcuts, but the default opening screen is now the Agent Command Center rather than a file explorer.

The Agent Command Center shows running agent sessions, their status, and a log of what each session has completed or is currently doing. According to Scott Wu and Jeff Wang in the launch announcement, the design intent is explicit: Devin Desktop is an IDE with an agent manager built in, not an agent tacked onto a code editor. That is a meaningful shift from how most vibecoder IDEs have positioned themselves.

For most users, the immediate experience is subtle: the app looks different, the default screen changed, and a new agent option called Devin Local appears in settings. The urgent task before July 1 is ensuring your workflows do not break when Cascade is removed, particularly if you have CI scripts or project configuration files that reference Cascade-specific options.

What Did Devin Local Replace in Cascade

Devin Local is not an incremental update to Cascade. Cognition rewrote the local agent from scratch in Rust using the same architecture that runs the cloud Devin agent. The headline improvements are a 30% reduction in token consumption on equivalent tasks, native subagent support, and a bundled context-retrieval subagent called Fast Context.

Cascade was a single-context agent: one context window, sequential turns, one task at a time. Devin Local adds subagents, meaning a parent session can spawn helper sessions for specific subtasks and receive results back before continuing. This is the same delegation architecture that makes the cloud Devin agent useful for longer autonomous runs.

Fast Context is a subagent that handles code navigation using SWE-grep, a search tool designed specifically for retrieving relevant code context. Cognition reports it finds relevant context up to 20 times faster than Cascade's file retrieval approach, at throughput above 2,800 tokens per second. For large codebases, that directly reduces the latency of common operations like "find all callers of this function" or "locate where this config value is defined."

The 30% efficiency figure comes from Cognition's own comparison and has not been independently verified at launch. The improvement comes from the Rust rewrite and tighter harness instrumentation, not from a model change. Devin Local uses whatever underlying model you configure in settings. Pricing follows the same structure as Cascade: prompt-based credit plans carry over with no changes.

How Does ACP Change Which Agent You Can Use in Your Editor

Devin Desktop launches with support for the Agent Client Protocol (ACP), an open standard created by Zed Industries in August 2025 that standardizes communication between IDEs and AI coding agents. ACP is to agent-editor integration what the Language Server Protocol was to language tooling: a shared contract that decouples one side from the other.

Before ACP, each editor-agent combination required a custom integration built by one of the two vendors. Cursor's agent worked in Cursor. Devin worked in Windsurf. Using a different agent in a different editor meant waiting for someone to build and maintain the specific pairing you wanted.

With ACP support, Devin Desktop at launch can run Codex, Claude Agent, and OpenCode alongside its own Devin Local, and any other agent that implements the protocol. The protocol uses JSON-RPC 2.0 over stdin/stdout, which is a low-friction integration target for agent developers. JetBrains, Google, GitHub, and more than 25 agents have adopted ACP since it launched last year. The JetBrains ACP agent registry gives a good sense of what compatibility looks like in practice.

The practical consequence for vibecoders: if both your editor and your preferred agent support ACP, you no longer need to wait for a vendor-built integration. You can test Claude Code or Codex inside Devin Desktop today using the ACP connection without switching editors.

What Are Spaces and How Do They Help Multi-Agent Work

Spaces is a new organizational primitive in Devin Desktop that groups related agent sessions, pull requests, files, and context objects under a shared namespace. A Space persists across sessions; agents started inside a Space inherit the accumulated context from previous sessions in that Space rather than starting from a blank slate.

Before Spaces, each agent session started fresh. A multi-day feature involving ten agent sessions required each new session to re-establish context about the codebase, the open PR, and decisions made in prior sessions. Spaces automates that handoff, which matters most for longer or multi-agent workflows where context reconstruction adds overhead on each new session.

For vibecoders working on short-scoped projects with fresh agent sessions each time, Spaces will not change much immediately. The benefit shows up after the second or third session inside the same Space, when accumulated context starts reducing the setup overhead on each new run.

What This Means For You

The actionable checklist before July 1 is short but specific:

• Test Devin Local now: Run it on a project you know well and verify it handles the workflows Cascade covered. The 30% token efficiency headline may not apply uniformly to every workload type.
• Audit your configuration files: Search for .windsurf directories or any Cascade-specific CLI flags in your scripts. Devin Local replaces Cascade at the binary level.
• Try ACP with a second agent: The ACP integration is live. Running Claude Code or Codex inside Devin Desktop is now a configuration step, not a feature request.
• Create a Space for your active project: If you have ongoing agent work, start a Space and run your next few sessions inside it to see whether context accumulation reduces your setup time.

The broader competitive signal is worth naming. Cursor's June 2026 updates focused on enterprise organizational features for larger teams. Devin Desktop is making a different bet: that the next axis of competition in agentic IDEs is agent management, shared context across sessions, and open protocol interoperability rather than just editor experience or model quality. Both bets may be right for different segments of the market.

Full migration details are in the Devin Desktop announcement and the Cognition introduction post. ACP documentation for connecting additional agents is at jetbrains.com/acp.