Daniel Kim

Posted on Aug 13

Windsurf Is Now Devin Desktop — And Its Best Feature Is an Exit Ramp From Devin

#ai #devtools #ide #opensource

On June 2, 2026, everyone who had Windsurf open on their machine restarted the editor and found a different name on the title bar: Devin Desktop. No migration wizard, no reinstall, no email campaign — just a standard over-the-air update that quietly finished a corporate story that started a year earlier with a $3 billion deal that fell apart, a $2.4 billion licensing agreement that poached the CEO, and a much smaller acquisition that picked up whatever was left.

That backstory matters more than the rename itself, because it explains why Cognition — the company behind the autonomous coding agent Devin — was willing to bolt a well-liked, independently branded IDE onto its own product line instead of just running it as a subsidiary. And buried inside the announcement is a feature that's more interesting than the rebrand: Cognition shipped an open protocol that lets you run a competitor's agent — Claude Code's agent, OpenAI Codex, Google's Gemini CLI — inside the editor it just spent a year unifying under its own brand. That's either a confident bet or a tell. This piece is about which.

The fast version of a messy year

Windsurf (formerly Codeium) spent 2025 as one of the hottest names in AI-assisted coding, reporting $82M ARR, 350+ enterprise customers, and hundreds of thousands of daily active users by the time acquisition talk started. OpenAI was reportedly close to buying it for around $3 billion. That deal collapsed — reporting points to overlap concerns tied to OpenAI's relationship with Microsoft — and the exclusivity window lapsed. Google DeepMind moved immediately, paying $2.4 billion for a non-exclusive license to Windsurf's technology and hiring away CEO Varun Mohan, co-founder Douglas Chen, and a chunk of the research team, without buying the company itself.

That left a product with real revenue and a real user base, but no leadership and no owner. Cognition stepped in on July 14, 2025, acquiring the remaining team, the IP, the trademark, and the brand in a deal reported at a fraction of the earlier valuations. Windsurf spent the following eleven months operating semi-independently before Cognition finished the integration on June 2, 2026, folding it into a single product family: Devin Desktop (the editor), Devin Cloud (the autonomous cloud agent), Devin CLI, and Devin Review. The rename is step three of a three-step story, not a standalone event — which is worth knowing before you evaluate anything else about it.

The bet paid off on paper, at least so far: Cognition closed a funding round on May 27, 2026 — before the rebrand even shipped — reportedly valuing the combined company at $26 billion. That's the number that explains the confidence behind opening every user's editor onto an "agent management" screen instead of a blank file: Cognition isn't hedging that Devin Desktop will remain a niche editor, it's pricing the whole company as if agent orchestration, not code completion, is the product category that matters going forward.

What Devin Desktop actually is

Strip away the branding and Devin Desktop is a VS Code fork — same lineage Windsurf always had — with one structural change: the default screen you land on is no longer a blank editor canvas. It's the Agent Command Center, a Kanban board that shows every agent session you have running, local or cloud, grouped by status: in progress, blocked, ready for review.

Cognition's own framing, from the launch post: "Devin Desktop is a full IDE with an agent manager built in — not the other way around." The editor, extensions, keybindings, LSPs, and workflows carry over unchanged and stay backward-compatible with both Windsurf and vanilla VS Code, so nothing you had configured breaks. What changes is what you see first, and what that implies about how Cognition expects you to work: scope a task, hand it to an agent (or several), review diffs, and drop into the editor only for the last-mile edits.

Two other pieces ship alongside the Command Center:

Spaces — a way to group everything related to one task: agent sessions, pull requests, files, and shared context, so a new agent session inherits the context of the space instead of starting cold.
Devin Local — the replacement for Cascade, Windsurf's original local agent. Cognition rewrote it from scratch in Rust, claims it's up to 30% more token-efficient, and added native subagent support. It became the default agent on the same day as the rebrand.

Two more pieces round out the "how it works" picture, and they matter more than they sound like they would from the feature-list version. Deep Wiki gives symbol-level understanding: hover a function or class, and instead of a bare type signature you get an explanation of what it does and how it's used, generated on demand rather than pre-indexed. Codemaps does the same thing at system level — ask a question like "how does authentication work," and a specialized agent walks the repo and builds a clickable, hierarchical map of the answer, which can be shared as a link for onboarding or design review instead of re-explained by a human every time a new engineer joins. Both are aimed squarely at the actual bottleneck in agent-assisted development, which isn't writing code — it's an agent (or a human) building enough context about an unfamiliar codebase to act correctly in it. Subagents also ship with fine-grained permissions, so a parent task can delegate sub-tasks to scoped agents without handing every subagent the same blast radius as the top-level session — a detail enterprises evaluating this for anything beyond a personal side project will care about more than the Kanban board.

The part that's actually new: ACP

The mechanically interesting change is the Agent Client Protocol (ACP), an open, Apache 2.0-licensed spec that Cognition ships Devin Desktop with support for at launch. The pitch, in the words of Cognition's own product tour: ACP does for coding agents what the Language Server Protocol did for language tooling. Instead of every editor writing custom integration code for every agent, an agent implements the ACP interface once and any ACP-compatible editor can host it.

At launch, that means Codex, Claude Agent, Gemini CLI, OpenCode, and Junie all run as first-class citizens inside Devin Desktop — not as embedded terminals or awkward extensions, but with the same Kanban presence, the same Spaces integration, and the same review flow as a native Devin session. Cognition explicitly says custom in-house agents your team builds can plug in the same way. Early enterprise design partners named in the launch post — Ramp, Harvey, and NVIDIA — are quoted specifically about running "an array of agents" or "multiple agents across complex workflows" from the same interface, which is the actual use case ACP is built for: teams that have already standardized on more than one agent and don't want a separate window per tool.

This is the detail that makes Devin Desktop more than a re-skinned IDE. A protocol that lets Claude's agent or OpenAI's agent run natively inside Cognition's own editor is a genuine bet that the IDE layer, not the agent layer, is where the durable product sits — and it's a bet against lock-in, coming from a company whose entire brand strategy over the past year has been consolidation under one name. Whether that's principled or just pragmatic (a smaller player inviting bigger agents in to keep its editor relevant) is a fair question, and the launch materials don't really engage with it.

There's a trust-boundary question underneath the convenience, too, and it's one every ACP announcement glosses over. Running Codex or Claude Agent inside Devin Desktop means a third-party vendor's agent gets access to your repo, your terminal, and whatever MCP servers you've connected — Stripe, GitHub, Slack, Figma — through Cognition's editor rather than through that vendor's own sandboxed CLI. The fine-grained permissions on subagents help, but ACP as a spec standardizes the wire protocol between editor and agent; it doesn't by itself define a shared, auditable permission model across agents from competing vendors running in the same workspace. For a solo developer that's a non-issue. For a security team deciding whether to let three different companies' AI agents touch the same production credentials from inside one editor, it's a policy question nobody has fully answered yet, including Cognition.

What changed versus the competition

Before the rebrand, the AI-IDE landscape mostly split into two camps: editors with one strong built-in agent you were expected to use (Cursor with its own models and Composer, Windsurf with Cascade), and terminal-first tools that treat the editor as optional (Claude Code, Codex CLI, Aider). ACP pushes Devin Desktop toward a third position — an agent-agnostic host — that neither camp fully occupies yet. Cursor lets you switch underlying LLMs but the orchestration layer is still Cursor's own; Claude Code and Codex CLI are agents first and don't function as multi-agent hosts for competitors. GitHub Copilot Workspace remains the most walled-garden of the group.

Practically, that means the meaningful competitive question for a team choosing an editor in late 2026 isn't just "which agent is smartest this month" — it's whether you want to bet on a single-agent product or an agent-agnostic host that lets you swap frontier models as they leapfrog each other without changing tools. That's a genuinely different axis of comparison than "Cursor vs. Windsurf" was a year ago.

It's also worth being precise about what Devin Desktop is not competing on. Cognition's in-house model, SWE-1.6, is reported to score 11% higher than its predecessor SWE-1.5 on SWE-Bench Pro, with a fast tier running at roughly 950 tokens per second for paid plans — respectable, but Cognition isn't claiming SWE-1.6 beats the frontier labs' flagship coding performance, and the ACP bet is arguably an admission of that: if your own model isn't guaranteed to stay the best choice for every task, the safer product strategy is to make sure developers stay on your editor even when they pick someone else's model to do the work. Cursor has quietly converged on a similar posture by supporting multiple third-party models rather than only its own; the difference is that Cursor mediates those models through its own orchestration layer, while ACP is explicitly designed so the third-party agent's own harness — its own prompting, its own tool-calling logic — runs unmodified inside the host editor. That's a deeper form of openness than "pick your model from a dropdown," and it's the part of this launch actually worth tracking over the next year, independent of whether Devin itself impresses anyone.

Why developers should actually care

Lock-in. If ACP adoption spreads beyond Devin Desktop's launch partners, the practical effect is that your choice of editor and your choice of agent become independent decisions again — you're not stuck with Devin's model just because you're stuck with Devin Desktop's UI, and vice versa. That's a meaningfully different value proposition than "our agent is better than theirs," and it's the kind of infrastructure bet that either becomes the new normal (the way LSP did) or quietly dies if no other major agent vendor reciprocates by supporting the protocol on their own editors.

Cost. Pricing did not change with the rebrand — Cognition's FAQ is explicit that existing Windsurf plans, including legacy Enterprise contracts, carry over untouched. But the pricing history that led into this rebrand is relevant context: Windsurf replaced its credit system with daily and weekly usage quotas on March 19, 2026, and raised the Pro plan from $15 to $20/month in the same move, which drew significant community backlash over opaque limits. Current published tiers land at Free, Pro ($20/mo), Max ($200/mo), and Teams (a $40/month full seat that unlocks usage across Devin Desktop, Cloud, CLI, and Review). If you were burned by the March quota change, nothing in this rebrand fixes that — it's the same billing model wearing a new name.

At $20/month, Devin Desktop Pro now sits above GitHub Copilot's $10 entry tier and roughly level with Cursor, while undercutting Replit's $25 agent-first plan — but the comparison that actually matters is the billing shape, not just the sticker price. Copilot and Cursor Pro are still flat-fee-with-soft-limits products; Windsurf's March 2026 switch to hard daily/weekly quotas puts it closer to a metered-usage model wearing a subscription's clothing, which is precisely what the backlash was about — a $20 bill doesn't tell you in advance how much agent time it actually buys you in a busy week versus a quiet one.

Migration risk, on a deadline. Cascade, the agent Windsurf users have relied on since 2024, is end-of-life on July 1, 2026. Devin Local is the mandated replacement, and any CI pipeline, workflow rule, or automation script that explicitly invokes Cascade needs to be repointed before that date. That's a real operational task, not a footnote, and coverage of the launch mostly buried it under the rebrand headline.

Reliability of the "better" agent. The 30%-more-token-efficient claim for Devin Local is vendor-stated; there's no independent benchmark backing it as of this writing, and it should be treated as a marketing number until third-party testing lands.

What the marketing leaves out

Devin Local shipped in preview, and at launch it's missing six capabilities Cascade users may actively depend on:

Capability	Cascade	Devin Local (at launch)
Persisted Memories	Available	Not yet
Workflows	Available	Not yet
Codemaps	Available	Not yet
App Deploys	Available	Not yet
Conversation Sharing	Available	Not yet
Fast Context UI	Available	Not yet

If your process leans on persisted Memories to carry project conventions between sessions, or saved Workflows to script repeated tasks, Cascade is the safer choice until the July 1 cutoff — after which you'd need to have moved anyway. Cognition's own docs flag these as Devin Local limitations, so this isn't a hidden gap, but it's easy to miss if you only read the launch blog post and not the fine print.

Independent testing from a month of real project use (three projects, small to medium, run by a reviewer at Emergent) backs up a pattern worth knowing before you commit a team to this: Cascade/Devin Local is genuinely capable at multi-file, cross-session tasks, but mid-task course corrections force a full restart rather than an incremental fix — there's no graceful "no, do it this way instead," you eat the sunk cost and start over. The same review notes that billing support, when the quota system produces a dispute, is "mostly bots." Reviews on Trustpilot, G2, and Reddit reportedly split cleanly along one line: people who stayed inside their quota are happy, people who pushed past it are not.

Practical use cases

Where this actually fits, based on what's shipped rather than what's promised:

Teams already running more than one agent. If your org has developers on Claude Code, others on Codex, and a few holdouts on a homegrown agent, ACP is the concrete reason to look at Devin Desktop now rather than waiting — it's the one place that claims to host all of them without picking a winner.
Delegating long-running work. The one-click handoff from a local Devin Local session to Devin Cloud — which spins up its own VM, keeps working after you close your laptop, and opens a PR for review — is the same pattern Devin has always sold, just now reachable from inside the editor instead of a separate dashboard.
Onboarding and cross-team context. Codemaps (symbol- and system-level explanations of a codebase, shareable as links) and Deep Wiki-style hover explanations are aimed at exactly the "new engineer joins a large repo" problem, and reviewers who tested them found them useful for that specific case.

Where it doesn't fit: anyone who needs the six Devin Local gaps listed above right now, and anyone who was already unhappy with the March 2026 quota change — this update doesn't touch that.

Concretely, a team migrating this month would do it in roughly this order: audit any CI script or workflow rule that names Cascade explicitly, since those break silently after July 1 rather than with a clear error; pick two or three ACP-compatible agents your engineers already have accounts for (Claude Agent and Codex are both supported at launch) and let people run whichever performs best for their task instead of standardizing on Devin Local by default; and treat the Agent Command Center as a review queue, not a to-do list — its actual value is in catching agent work that's silently blocked or has been running too long, not in replacing a project tracker.

Verdict

The rebrand itself is not the story — it's a routine consolidation after a genuinely turbulent acquisition year, delivered with unusual care (automatic settings migration, no forced reinstall, unchanged pricing) that most companies handling a three-way M&A mess would not have bothered with. The real story is ACP: a smaller player, coming off a year of nearly losing the product entirely, choosing to make its own IDE hostable for rival agents instead of trying to trap users inside Devin specifically. That's a bet that the IDE — the surface, the context management, the review workflow — is the moat, not the model underneath it. It's a defensible bet, and if other editors reciprocate by adopting ACP the way they adopted LSP, it's good for every developer regardless of which agent they prefer. It just hasn't been proven yet, and the parts of this launch that ship today unfinished (Devin Local's missing six features) are a reminder that the protocol story and the product-quality story are running on separate timelines.

Try it now if you're already a Windsurf user (the upgrade is free and automatic) or if your team runs multiple agents and wants one place to manage them — that's the use case ACP was built for.

Wait if you rely on Cascade's Memories, Workflows, or Codemaps daily; give Devin Local a few more months to close the gap, and watch whether the July 1 Cascade sunset gets extended.

Skip it if you were already frustrated by the March 2026 quota change or need predictable, contract-grade support — nothing here addresses either, and Cursor or Claude Code remain more predictable single-agent alternatives in the meantime.

What's your read: does an agent-agnostic protocol like ACP actually survive contact with vendor incentives — the way LSP did — or does every big agent vendor eventually route around it once their own agent is good enough to want the lock-in back?

Sources:

DEV Community