The Windsurf IDE is now Devin Desktop. Cognition acquired Windsurf in July 2025 and shipped the rename through an over-the-air update on 2 June 2026; windsurf.com now redirects to devin.ai. Existing projects, plans, settings, extensions, and keybindings carried over. The current editor combines Supercomplete, Fast Context, inline edits, an Agent Command Center, Spaces with shared context and git worktrees, Devin Local, cloud agents, and third-party agents through Agent Client Protocol. Cascade reached end of life on 1 July 2026. Windsurf for JetBrains remains available under that name. The product direction is clearly toward one local-and-cloud agent command center, but extension compatibility, plan terms, agent behavior, and the final boundary between Desktop and Devin Cloud should be evaluated from shipped behavior rather than assumed from the roadmap.
- Windsurf IDE is now Devin Desktop. The rename shipped in place on 2 June 2026.
- Existing projects, settings, extensions, keybindings, and plans carried over; this was not a forced repository migration.
- Cascade reached end of life on 1 July 2026. Devin Local is the current bundled local agent.
- The editor’s current center is an Agent Command Center, with Spaces, worktrees, local agents, cloud agents, and ACP support.
- Windsurf for JetBrains remains available, so the Windsurf name still applies to plugins even though the desktop brand changed.
- The factual direction is local-plus-cloud consolidation; the final product boundary is uncertain and should not be invented.
What happened to Windsurf IDE
Cognition acquired the company behind Windsurf on 14 July 2025. On 2 June 2026 it renamed the standalone Windsurf editor Devin Desktop. The change shipped through an ordinary over-the-air update, and Cognition's announcement says existing plan, pricing, extensions, settings, and keybindings carry over automatically. windsurf.com now redirects to the Devin desktop product.
That sequence is a rename and consolidation, not a discontinuation. The editor still opens repositories, provides completion and inline editing, runs agents, and supports extensions. What changed is its place in the company portfolio. Windsurf was an AI editor with a cloud-agent story around it. Devin Desktop is presented as the desktop command center for Cognition's local and cloud software-engineering system.
| Question | Current answer |
|---|---|
| Does the desktop editor still exist? | Yes, as Devin Desktop |
| Did existing users reinstall? | No, the rename arrived as an over-the-air update |
| Did projects and settings migrate? | They carried over in place |
| Does windsurf.com work? | It redirects to devin.ai |
| Is Cascade current? | No, end of life 1 July 2026 |
| Is the Windsurf name gone everywhere? | No, Windsurf Plugins and the JetBrains route retain it |
| Is pricing still the old Windsurf credit ladder? | No, current billing uses Devin plans and quota |
What the editor is now
Devin Desktop remains a full editor, descended from the VS Code-shaped Windsurf product, with code navigation, extensions, completion, inline edits, terminal work, and agent surfaces. Cognition's current differentiation is not that it added an agent to an editor. Every serious AI editor has one. It reorganized the product around several agents whose work can be local or cloud-hosted.
The Agent Command Center is the visible expression of that change. It groups work into states such as running, waiting for review, and done. That makes the editor less like one conversation attached to one window and more like a board for work in flight. The product still has an editor buffer, but the strategic unit is increasingly the task and its agent rather than the cursor.
| Layer | Current Devin Desktop role |
|---|---|
| Editor buffer | Read, navigate, and edit code directly |
| Supercomplete | Predictive completion and next-edit assistance |
| Inline edits | Bounded transformations in the code surface |
| Fast Context | Retrieve relevant repository context for edits and agents |
| Agent Command Center | Track local and cloud work by state |
| Spaces | Share context and git-worktree structure across agents |
| Devin Local | Bundled local agent |
| Devin Cloud | Run delegated tasks in Cognition-managed environments |
| Agent Client Protocol | Host third-party agents through an open protocol |
Supercomplete, Fast Context, and the editing loop
Supercomplete is the predictive editing layer. Its job is to infer the likely next code change while a developer remains in control, including edits beyond the exact cursor location. The value is not measured in generated lines. It is the number of correct changes accepted without interrupting thought, minus the time spent checking and rejecting bad predictions.
Fast Context retrieves relevant repository code, while inline edits cover bounded transformations the developer reviews immediately. Both belong to the short interactive loop. They should be judged on selected-context quality and correction latency, not on the autonomous task benchmark used for cloud agents.
| Work shape | Best surface inside Desktop |
|---|---|
| The next mechanical edit is obvious | Supercomplete |
| A selected block needs a bounded rewrite | Inline edit |
| The relevant implementation is unclear | Fast Context and search |
| A task needs several tool calls while you watch | Devin Local |
| Several independent tasks should proceed | Command Center and Spaces |
| A task should outlive the laptop | Devin Cloud |
Cascade is gone; Devin Local is the bundled agent
Cascade was the agent name most closely associated with Windsurf. Cognition retired it on 1 July 2026. The current bundled local agent is Devin Local, described in the site's compare data as a Rust rewrite with parallel subagents and improved token efficiency according to Cognition. The product-level change is automatic for ordinary in-editor use.
Automation is the exception. A script, internal document, shortcut, or integration that calls Cascade by name cannot infer a new command merely because the desktop application updated. Those references need an explicit audit and migration. This is the same pattern as any API rename: UI continuity does not guarantee programmatic compatibility.
| You used | What to do |
|---|---|
| Cascade only through the editor UI | Use the current Desktop agent surface; the product migrated in place |
| Scripts that invoke Cascade | Replace the named dependency with the supported Devin Local path |
| Internal onboarding screenshots | Update the name and command-center layout |
| Prompts or rules tied to Cascade behavior | Retest them; a renamed or rewritten agent can behave differently |
| Billing assumptions tied to Cascade credits | Move to current Devin quota and overage terms |
A current agent should be tested as a current agent. Do not carry forward benchmark claims, prompt recipes, or quota expectations from Cascade without evidence. The harness, model routing, context behavior, and parallel execution can all alter the result even when the editor feels continuous. Use the same repository task and acceptance gate to compare old records with current behavior.
Spaces, worktrees, and the command center
Parallel agents create an isolation problem before they create a model problem. Two agents in one checkout can overwrite files, pollute build outputs, and make the final diff impossible to attribute. Spaces address that class of work with shared context and git worktrees, allowing tasks to remain related without sharing one mutable working tree.
The command center addresses the human side. Running, waiting-for-review, and done states are more useful than six terminal tabs because they tell the reviewer where attention is required. The board does not increase review capacity. It makes the queue visible, which is the prerequisite for limiting it.
| Parallel-work problem | Desktop response | Remaining responsibility |
|---|---|---|
| Agents overwrite one checkout | Git worktrees in Spaces | Choose clean base commits and integration order |
| Context drifts between related tasks | Shared Space context | Keep instructions current and task-specific |
| Nobody knows what needs attention | Command-center status | Define what “waiting for review” requires |
| Several branches finish at once | Visible completed queue | Enforce a human review WIP limit |
| Changes conflict during integration | Isolation preserves separate diffs | A person or explicit integration task resolves contracts |
| Cloud and local work diverge | One command-center concept | Verify environments and evidence separately |
A practical limit is two active implementation agents per reviewer until evidence supports more. If two branches arrive cleanly, pass checks, and receive prompt review, add another lane. Starting with eight because the interface can display eight creates a larger inventory of untrusted code, not leverage.
Why Agent Client Protocol matters
Agent Client Protocol, or ACP, is the most strategically important portability feature in the current Desktop story. It allows the editor to host agents through a protocol rather than requiring every agent to be a Cognition implementation. That can make Devin Desktop the command surface even when a developer prefers Claude, Codex, or another compatible agent for a task.
Protocol support does not make agents interchangeable. Each agent retains its own models, permissions, configuration, tools, authentication, quota, and output behavior. The editor can normalize connection and presentation while the underlying capability and bill remain different. A team should document which provider owns each session rather than treating the Desktop logo as the billing source.
| ACP can standardize | ACP does not standardize automatically |
|---|---|
| How an editor connects to an agent | Model quality and reasoning behavior |
| Basic session and message transport | Provider authentication and plan limits |
| A shared place to present agent work | Filesystem, network, and command permissions |
| Lower switching cost between compatible agents | Tool semantics and extension ecosystems |
| Command-center visibility | Cost reporting across every provider |
Extensions, JetBrains, and migration risk
Cognition states that extensions, settings, and keybindings carry over to Devin Desktop. That is the right default for an in-place update, and it removes the largest immediate migration cost. It is not a lifetime compatibility warranty. A VS Code-derived editor evolves independently, and an extension can depend on APIs, authentication flows, or native components that behave differently.
The only responsible test is the short list of extensions the developer cannot work without. Install or activate each in the current build, open a representative repository, and exercise the critical command. Do the same for debugger, test explorer, remote development, container tooling, and language servers. A marketplace listing is weaker evidence than a five-minute working test.
JetBrains users do not follow the same name path. The Devin Desktop FAQ says Windsurf for JetBrains continues to be available. That preserves the plugin surface for IntelliJ-platform users and preserves the Windsurf name. It also means documentation can use two brands for related products, so version and platform should accompany every internal instruction.
Inventory critical editor dependencies
List only extensions, language servers, debuggers, remote tools, and keybindings that would block adoption if they failed.
Test the current build
Open a real repository and exercise each dependency. Do not infer compatibility from the old Windsurf build.
Export settings and ordinary project state
Keep configuration backed up and repositories in normal git so a future editor change remains reversible.
Name the platform in documentation
Write Devin Desktop for the standalone editor and Windsurf for JetBrains where that is the actual product.
Retest on major updates
The product is consolidating quickly. Pin or stage updates for a team whose editor is release-critical.
Pricing under Devin
New users see the Devin plan ladder: Free, $20 Pro, $200 Max, Teams with an $80 monthly floor and $40 full developer seats, and custom Enterprise. Free has a light quota and limited model availability; current site coverage lists unlimited inline edits and Tab completions. Pro has daily and weekly quota. Max has weekly quota without a separate daily cap.
Existing Windsurf Pro users at $15 a month and Teams users at $30 per developer seat can retain grandfathered prices under the documented migration. That is why an old invoice can be lower than the public page. New buyers should not use grandfathered rates in a comparison.
| Buyer | Current starting point |
|---|---|
| Trying the editor | Free |
| Regular individual editor and agent use | Pro, $20/mo |
| Heavy, bursty individual agent use | Max, $200/mo |
| Team with unequal usage | $80 floor, $40 full seats, free flex seats |
| Existing eligible Windsurf subscriber | Grandfathered $15 or $30 rate where documented |
| Organization needing SSO, deployment choices, and support | Enterprise |
The plan covers more than an editor seat. The detailed quota, overage, Teams, and grandfathering mechanics are in Windsurf pricing after the Devin rename.
Where the product is heading, without pretending to know the roadmap
The shipped direction is clear: one Cognition account and command center across local editing, local agents, cloud agents, worktree Spaces, and third-party agents. The rename itself communicates that the editor is no longer a sibling brand. It is the desktop surface of Devin.
The final boundary is not clear, and it would be irresponsible to invent one. Cognition may integrate plans, context, review, and handoff more deeply. ACP may make the editor increasingly agent-neutral. Enterprise customers may receive deployment and policy paths that differ from self-serve. None of those possibilities should be stated as a shipped commitment until the product or documentation says so.
| Evidence today | Reasonable inference | Not established |
|---|---|---|
| Windsurf renamed Devin Desktop | Cognition wants one Devin product identity | Every Windsurf plugin will be renamed immediately |
| Command Center spans local and cloud agents | The desktop is becoming an agent-operations surface | The editor buffer will become secondary for every user |
| Spaces use shared context and worktrees | Parallel work is a core product bet | Parallel agents eliminate integration and review bottlenecks |
| ACP hosts third-party agents | Agent choice can become more portable | All compatible agents will have feature parity |
| One plan ladder covers the suite | Commercial consolidation is real | Prices or quotas will remain unchanged |
The correct hedge is reversible adoption. Keep repositories in standard git, keep critical instructions in portable files, avoid automation that depends on a marketing name, retain exports of settings, and test required extensions on updates. A team can use the current product confidently without betting its development process on a guessed destination.
Who should use Devin Desktop now
| You want | Best interpretation |
|---|---|
| Predictive completion and agent work in one editor | Devin Desktop is a direct fit |
| A visible board for several local and cloud agents | The command center is the differentiator |
| Worktree-aware shared context inside the IDE | Evaluate Spaces on real parallel tasks |
| Third-party agents without leaving the editor | Test ACP with the exact provider workflow |
| The largest current ecosystem and Tab-first steering | Compare Cursor directly |
| Only terminal delegation in an existing editor | Use Claude Code or Codex before changing IDEs |
| Mobile supervision, multiple provider accounts, remote hosts, and a repo cost ledger | Add a workbench beside the editor |
Devin Desktop is a strong candidate for developers who want the editor itself to become the agent command center. The feature combination is real: predictive editing, retrieval, local agent work, cloud handoff, parallel Spaces, and protocol-based third-party agents. The acquisition gave Cognition a credible local surface rather than forcing every task through a remote service.
It is a weak choice when the team does not want another editor, needs one unsupported extension, or already delegates all large work through terminal agents and receives no value from completion. In those cases the command center may be attractive while the editor migration remains unjustified. A separate workbench can cover multi-agent operations without owning the buffer.
A one-week evaluation
A current Windsurf evaluation should test the renamed product, not memories of Cascade or a $15 comparison. Use one normal editing day, one bounded local-agent task, one parallel Space, and one cloud handoff. That covers the product thesis without turning the trial into a migration project.
Start on Free with a real repository
Import no special demo. Open the code you work on, confirm language tooling, and keep the repository on an ordinary clean branch.
Test the editor loop
Measure accepted Supercomplete suggestions, useful inline edits, retrieval quality, latency, and the time spent rejecting predictions.
Verify critical extensions
Exercise debugger, test explorer, remote or container tooling, language servers, and the few extensions that can block adoption.
Run one bounded Devin Local task
Name exact scope and checks, then inspect the plan, commands, diff, tests, and quota change. Do not judge from prose fluency.
Create two isolated tasks in Spaces
Confirm worktree isolation, shared context behavior, status transitions, and the review queue. Stop at two agents until both diffs are understood.
Test cloud continuation only if needed
Use a task that can run in a managed environment and should outlive the laptop. Verify repository access, secrets, result, and cost separately from the local run.
Decide what earned the seat
Name whether completion, context, local agents, command center, Spaces, ACP, or cloud work saved time. Pick the plan only after identifying the winning job.
Questions people ask
The standalone desktop editor is called Devin Desktop. Cognition shipped the rename through an over-the-air update on 2 June 2026, and windsurf.com now redirects to devin.ai.
No. The desktop editor continues as Devin Desktop. Existing projects, settings, extensions, keybindings, and plans carried over. Windsurf Plugins and the JetBrains route continue to use the Windsurf name.
Cascade reached end of life on 1 July 2026. Devin Local is the current bundled local agent. Scripts and documentation that invoke Cascade by name need an explicit migration.
Supercomplete, inline edits, Fast Context, an Agent Command Center, Spaces with shared context and git worktrees, Devin Local, cloud-agent access, and third-party agents through Agent Client Protocol.
Cognition says extensions, settings, and keybindings carry over. Test the few extensions, debuggers, language servers, and remote tools that are critical to your workflow in the current build before standardizing.
Devin Desktop has a Free plan with light quota and limited model availability. The site’s current coverage lists unlimited inline edits and Tab completions, making Free useful for testing the core editor loop.
Yes, the current product supports third-party agents through Agent Client Protocol. Compatibility does not make model behavior, permissions, authentication, quotas, or billing identical, so test the full provider workflow.
Devin Desktop is stronger when you want an agent command center tied to local and cloud work, Spaces, and ACP. Cursor remains the stronger default for many developers whose main value is predictive Tab editing and a larger editor community. Try both on the work you do most.
The shipped direction is one Cognition command center across local editing, local and cloud agents, worktree Spaces, and third-party agents. The final integration and plan boundary is not established; buy current behavior rather than an inferred roadmap.
Sources
Every figure above was read from these pages on August 2026. Vendors reprice without notice; if you find a stale number, tell us.