On June 2, 2026, Cognition renamed Windsurf to Devin Desktop and shipped it as a standard update, no migration required. The rename wasn't cosmetic: the app now opens on an Agent Command Center, a Kanban board of every agent session running, local and cloud, sorted by status. The product used to be an editor with one agent inside it. It's now a surface for directing several agents at once, across however many repositories they touch.
What changed when Windsurf became Devin Desktop
Windsurf was an AI-native editor: an autocomplete, a chat, an agent mode that worked inside the open file, the same category as Cursor. Devin Desktop keeps that editor underneath, but leads with something different. Open the app and the first screen isn't a file, it's the Command Center: a board showing every agent currently running, in progress, blocked, or ready for review, whether it's running on your machine or in an isolated cloud VM. The shift in framing matters as much as the feature: the job in front of the person using it stops being "write this change" and becomes "direct these agents."
The Agent Command Center: one Kanban board, many agents
The board itself is a straightforward idea borrowed from project management, applied to agent sessions instead of tickets. Each card is an agent working a task, and its column is its status. What makes it worth a comparison isn't the board, it's what a board like this implicitly assumes: that a card's current state is a fair summary of what happened to get there. A card marked "ready for review" tells you an agent finished something. It doesn't tell you, on the board itself, what the agent touched to get there, what it was allowed to touch, or whether two agents working adjacent parts of the same repository stepped on each other's assumptions along the way.
What Spaces shares between agents, and what it does not
Spaces are how Devin Desktop groups related work: a Space bundles the agent sessions, pull requests, files, and context tied to one task or project into a single view, and a new session started inside a Space inherits what the Space already knows. That's a real answer to a real problem, agents working the same project without a shared Space would each rebuild context from scratch. What a Space shares is what an agent is allowed to see going in. It isn't a record of what each agent, once inside, actually did with that context: which file it edited, which command it ran, which of the Space's assumptions it relied on for a specific change. The Space is the briefing. It isn't the debrief.
The old subagent question, now across independent sessions
Claude Code's subagents raise a version of this problem inside a single session: a task splits across isolated contexts, each returns a summary, and reconstructing who did what, in what order, based on what, becomes a manual job nobody's tooling does by default. Devin Desktop's Kanban board is the same question at a wider scope. These aren't subagents inside one session answering to one parent context, they're independent agent sessions, sometimes started days apart, sometimes running on different machines entirely, coordinated only by which column their card sits in. If an agent on one card touches a file that a second agent, in a different Space, also depends on, nothing about the board surfaces that overlap. The board organizes the work a team is directing. It doesn't cross-reference what actually happened underneath each card.
What a board like this needs before it counts as a delivery record
None of this is an argument against a Kanban view over parallel agents, seeing what's in progress, blocked, or ready for review is a genuine improvement over guessing which of six terminal tabs is stuck. The board solves a real coordination problem for the person directing the work today. It wasn't built to answer a different question, one that shows up later: when a client asks why a specific file changed the way it did, which card, which agent, which Space, and on whose authorization, is the answer sitting in the board, or does someone have to reconstruct it from memory and git blame.
That's the same gap every coding agent leaves once the session that produced the code is over, just multiplied by however many agents a team runs in parallel on the same board. A Kanban view over agents is a coordination tool, and a good one. What still has to exist beside it is a record that ties each card back to what was requested, what that specific agent was authorized to touch, what it executed, and who can point to that chain after the board has moved on to the next sprint. Detent Bench measures agents on exactly that line, whether the work runs one agent at a time or a full board of them.
Sources: Devin's Windsurf 2.0 announcement, cross-checked against independent coverage published in the months after the June 2026 rebrand.