Windsurf Becomes Devin Desktop: Migration and the New Agent

What changed when Windsurf was renamed Devin Desktop?#

In the morning launch described here, a new name appeared in the editor’s top bar on June 3. No installation wizard, no “update here” screen. Just a new brand.

That was the launch of Devin Desktop. In essence, it is the same Windsurf, renamed and repackaged by Cognition. The same foundation, the same VS Code fork, but with a different home screen and a replacement for the local agent.

Key dates to remember:

• June 2, 2026 — the automatic update rolled out to all Windsurf users
• June 4, 2026 — Reset migration from Windsurf was added to the command palette for users who lost extensions or got logged out
• July 1, 2026 — Cascade, the old local agent, is being shut down for good
• After July 1 — check every automation that explicitly calls Cascade; the actual failure mode depends on that integration

What does this mean for users? If you used Windsurf in the editor as an “AI assistant with autocomplete,” there’s almost nothing to do. If you have scripts or CI tasks that call Cascade directly, you have three weeks to fix them.

Why Cognition did this#

The story begins 11 months before the rebrand. On July 14, 2025, Cognition announced the acquisition of Windsurf.

By the time of the deal, Windsurf was generating 82 million dollars in annual revenue and doubling its enterprise segment quarter over quarter. Cognition, meanwhile, had Devin—a cloud agent that performs tasks on its own, without a person in the loop. The logic is clear: combine the Devin cloud agent with the Windsurf desktop editor and create a single interface for managing cloud and local agents from one place.

This “single interface” inside Devin Desktop is called Agent Command Center—a Kanban board for agents where Devin Cloud, Devin Local, OpenAI’s Codex, Anthropic’s Claude Agent, and other compatible agents work together.

Windsurf has shifted from “an editor with AI” to “a control room for agents that includes an editor.” Cognition is aiming to make it the standard for team AI development—to make Devin Desktop in this category what Slack is for corporate messaging.

What transfers automatically, and what doesn’t#

In its FAQ, Cognition promises a “zero-effort migration” for most users. In practice, that means the following.

Transfers automatically:

1. Subscription plan — Free, Pro, Max, Teams, and Enterprise (including legacy Windsurf Enterprise) stay as they were.
2. Price — unchanged. Pro is still 20 dollars a month, Max is 200, and Teams is 80 per team plus 40 per member.
3. VS Code extensions — brought over from the old profile.
4. Keybindings and personal settings — copied as-is.
5. MCP connections — continue to work as before.
6. .windsurfrules files — Devin Desktop reads them without changes.

Does not transfer automatically:

1. CI/CD scripts that explicitly mention cascade in the command line or YAML files.
2. GitHub Actions that call --agent cascade or use a similar flag.
3. Custom hooks and automations that call Cascade as a named agent.

If you were logged out after the update or some extensions disappeared, that was a known bug in the first few days. You can fix it through the command palette: Ctrl + Shift + P on Windows and Linux, Cmd + Shift + P on macOS, then run Reset migration from Windsurf. This command appeared in version 3.0.21, released on June 4—two days after the rebrand—in response to complaints from early migrants.

Before migrating, it’s worth backing up three folders. Not out of paranoia, but because migrations are never “100% trouble-free”:

# macOS / Linux
cp -r ~/.config/Windsurf ~/.config/Windsurf.backup
cp -r ~/.windsurf ~/.windsurf.backup
cp -r ~/.codeium ~/.codeium.backup

If the migration goes wrong, you can restore the state and try again.

Cascade EOL on July 1, 2026: what to fix before the deadline#

Cognition puts it this way in its FAQ: as of June 2, Devin Local is the default agent, while Cascade remains available until July 1 to allow a gradual migration.

For interactive work, this means there’s nothing to do. Open the editor and start making requests—the agent is already Devin Local. If you want to switch back to Cascade temporarily for comparison, you can do so in the agent settings.

For CI/CD and automations, take these three steps before July 1:

1. Find all mentions of Cascade in your project. A single grep from the repository root catches almost everything:

grep -rn "cascade" .github/ .gitlab-ci.yml Jenkinsfile .windsurfrules .windsurf/ 2>/dev/null

If you have several repositories, repeat this for each one.

2. Verify the supported automation path before replacing a call. This article does not provide a verified Devin Local CLI command or version. Do not substitute a guessed binary name or agent flag. For each discovered Cascade call, record the current command, required non-interactive behavior, authentication method, and expected output. Check the official Devin documentation for a documented replacement that supports that workflow. Until its exact invocation and version are confirmed, leave this CI migration item explicitly unresolved and keep dependent release work blocked or use a separately approved, verified workflow.

3. Validate the documented replacement on staging once Step 2 is resolved. Run the same representative task through the verified invocation; inspect its exit status, logs, artifacts, and project checks. A green pipeline alone does not prove that the agent ran. If the invocation remains unverified, this step remains unresolved too.

A script that still depends on the retired agent may fail, skip its intended work, or report an apparently green build without the expected artifact. Check the actual integration rather than assuming a universal silent failure. Do not call the migration complete until the replacement’s intended work and checks have run.

Devin Local: the new agent written in Rust#

Devin Local has three important changes that Cascade did not have.

Rewritten from scratch in Rust. Cascade ran on Python and a JavaScript wrapper. Rust offers faster startup, lower memory use, and more stable behavior under load.

Up to 30% more token-efficient. That’s the vendor’s figure.

On small tasks in small projects, it may indeed be closer to 30%; on large projects with long file histories, the gain may be smaller.

Support for subagents and sandboxing. Cascade was one agent per session. Devin Local can launch helper agents for parallel subtasks and isolate them in a sandbox so they don’t touch files outside the permitted area.

The price stays the same.

That means you don’t need to buy a separate Cognition Platform subscription to use the new local agent. Existing Windsurf plans still work.

Agent Command Center: the new home screen#

The main visual change in Devin Desktop isn’t a new font or a different icon. It’s the shift in focus from the code editor to the agent management board.

In practice, it looks like a Kanban board: task columns, cards showing the agents working on them, progress, and statuses. All agents—the local Devin Local, cloud Devin Cloud, and compatible third-party agents—are visible in one view.

There’s a useful feature inside Agent Command Center: Spaces:

Spaces are groups of agents working on one project who can see one another’s context. For example, one agent writes code, another writes tests, and a third runs migrations. They’re in the same Space, so they can see what the previous agent did.

For teams, this is a significant upgrade. Before, each agent in Windsurf had its own session with no shared context. Now they coordinate.

For a solo vibe coder who runs one agent on one task, the Kanban board may seem excessive. If it gets in your way, you can remove it in settings, and Devin Desktop will open in the classic editor view.

If you’re on a team and code with a couple of colleagues, try Agent Command Center and Spaces—it’s a real upgrade. If you’re a solo entrepreneur building your project with AI agents, the familiar editor view is still there; just click “change home screen.”

ACP: an open protocol for agents#

ACP is the second major feature Devin Desktop has brought to the masses. It’s an open standard that started at Zed and is now supported by JetBrains, VS Code, GitHub, and dozens of others. It’s not Cognition-only and isn’t tied to one vendor.

Under the hood, ACP is a simple idea. Local agents communicate with the editor over JSON-RPC on stdin/stdout, like ordinary processes. Cloud agents use HTTP or WebSocket. No proprietary wrapper is required.

Agents Devin Desktop can run out of the box through ACP:

This means you can put several third-party agents side by side in one editor. One writes scripts with Codex, another checks the logic with Claude, and a third builds the UI with Gemini. They communicate with you and with each other through the same protocol.

The agent registry configuration is in ~/.windsurf/acp/registry.json. If you want to add an agent that isn’t in the ready-made list, or build your own, specify it in this file and it connects to Devin Desktop as a full participant.

Other editors that support ACP (according to the list at zed.dev/acp as of June 2026): Zed (native), JetBrains IDEs (through AI Assistant), VS Code (through an extension), Emacs, Neovim, marimo, Obsidian, and about a dozen more—over thirteen editors in total.

The number of compatible agents is growing quickly. At the June 2026 announcement, Cognition cited “25+ agents.” The registry on zed.dev/acp has already passed 50 agents and is updated every week.

What does ACP offer you as a vibe coder?

• If Cognition shuts down tomorrow or changes its pricing model, you can move the agents you’re used to running through Devin Desktop to Zed or JetBrains in one evening—the config is the same.
• You can build your own agent for your task and run it in any ACP-compatible editor without rewriting the wrapper.
• One editor supports them all—you don’t have to install five different apps to try Codex, Claude, and Gemini on one task.

There’s no magic here. ACP is an open standard for communication between editors and agents that the industry has been waiting for for a couple of years.

Config files: .windsurfrules → .devin/#

Cognition made the rules migration gradual. There’s no “update by midnight or it will break.”

Here’s what that means in practice.

The old .windsurfrules file sits at the repository root as a single file with a simple structure. The new .devin/ folder contains a set of YAML files, each for its own area of responsibility: rules for tests, rules for migrations, rules for the UI, and so on. This is more convenient in large projects where there are many rules spread across different contexts.

If you have both .windsurfrules and .devin/, .devin/ takes precedence. So you can keep both, gradually move rules from the old format to the new one, and not worry about conflicts.

When should you start migrating?

• Now — if you’re starting a new project. Write rules in .devin/ from the start.
• In a couple of weeks — if you have 5–10 rules in .windsurfrules. Moving them will take an hour.
• Before a team migration — if you have a large monorepo with dozens of rules and want to agree on a .devin/ structure with the whole team.
• Never — if the project is archived and .windsurfrules works. Compatibility is guaranteed.

Installing Devin Desktop and subscription terms#

Step 1. Install. Go to devin.ai/desktop and download the .dmg for macOS, .exe for Windows, or .AppImage for Linux.

Step 2. Sign up. Open Devin Desktop, and authentication will start in your browser.

Step 3. Free plan. If you plan to use Free, that’s all. You don’t need to pay; the quota is limited to 200 tokens per second, with basic models and no premium features. It’s enough to get acquainted with Devin Desktop.

Pro plan and above. Cognition uses Stripe to accept payments.

However, Cognition reserves the right to disable an account at its discretion. Each person decides whether to use the service with an understanding of this risk.

Alternatives: Cursor, Claude Code, Cline, Kilo Code#

If you didn’t like Devin Desktop after the migration, there are four notable alternatives. If you want to avoid a subscription, see this guide to which free AI agent for VS Code to install.

Choose based on your situation:

• I use Windsurf and I’m happy with it — stay on Devin Desktop. Compare alternatives after the migration, without pressure.
• I’ve never used an AI editor and want to try one — start with Claude Code. Simple installation, minimal setup, and Anthropic’s voice as its developer.
• I need open source and control over models — Kilo Code. Migration from Windsurf takes 30–90 minutes according to its official guide.
• I care about a polished interface and paired sessions — Cursor. The same 20 dollars.
• I live in the terminal — Claude Code again.

One-page migration checklist#

1. Update. Launch Windsurf after June 2. If “Devin Desktop” appears in the top bar, everything is fine. If not, check for automatic updates and restart.
2. Sign in again and check your extensions. If you were logged out or some extensions disappeared: Ctrl/Cmd + Shift + P → Reset migration from Windsurf.
3. Back up. Copy ~/.config/Windsurf, ~/.windsurf, and ~/.codeium before making major configuration changes, in case you need to roll back.
4. Check payment. If you’re on Pro and paid by card, make sure the billing went through. The payment processor may have changed after the acquisition.
5. Inspect your CI. Use the search from the EOL section to locate Cascade references, then inspect each integration and any additional script locations. Record the exact documented replacement and version before editing a call. A job without that evidence stays unresolved; after confirmation, run it on staging and verify the output artifact as well as the exit status.
6. Decide about Agent Command Center. If you work alone, turn off the Kanban board and work in the familiar view. If you’re on a team, try Spaces; it’s new and genuinely useful.

After July 1, check again—you’ll immediately see which scripts you missed.

What’s next: where AI editors are headed#

One conclusion suggests itself.

An IDE used to answer the question, “What am I editing?” A file, a project, a Git branch. Devin Desktop is trying to answer a different question: “What’s running?” Which agent is working on which task right now, which one is ready for review, and which one needs to be stopped.

JetBrains and Zed will move in the same direction through ACP. Cursor has already released Composer 2.5 with parallel agents—the same logic, just not through an open protocol. Open alternatives like Cline and Kilo Code will catch up through extensions.

For you as a vibe coder, this means one simple thing: the focus is shifting from “how I write prompts” to “how I manage the fleet of agents that execute them.” One or two tools whose habits you developed in Windsurf or Cursor will keep working. But if you want to stay ahead, it’s worth trying ACP, looking at Agent Command Center, and figuring out how one person can launch five agents on a single task at once.

Tomorrow, Cognition may rename it again, or OpenAI may release its own editor on ACP, or Google may launch Antigravity 3.0.