Cognition rebranded Windsurf as Devin Desktop and shipped it with a broader agent workflow. The Devin download page now describes Devin as “the command center for managing all your agents,” while the official announcement positions Devin Desktop as “a full IDE with an agent manager built in, not the other way around.”
That framing matters. Devin is no longer only an autonomous cloud agent you delegate work to. It now spans four surfaces: Devin Desktop, Devin Cloud, Devin CLI, and Devin Review. This guide walks through what changed, how to use the new workflow, and how Devin now compares with Cursor. If you want more editor-side context, read our guide to building APIs with Cursor Composer 2.5.
The big change: Windsurf is now Devin Desktop
If you already used Windsurf, you already have Devin Desktop. Cognition shipped the change as a standard over-the-air update. Plans, pricing, settings, and extensions carry over unchanged, so there is no migration step to run.
The practical difference is workflow. Windsurf was an IDE with AI features. Devin Desktop is an IDE centered around managing local and cloud agents.
Use the Agent Command Center to manage parallel work
When you open Devin Desktop, the default workspace is the Agent Command Center. It shows every local and cloud agent session on a board, grouped by status:
- In progress
- Blocked
- Ready for review
A practical workflow looks like this:
- Start one agent to refactor an API module.
- Start another agent to add unit tests.
- Start a third agent to prototype a UI change.
- Monitor all sessions from the Command Center.
- Review only the sessions that are blocked or ready.
This is the product-level version of the problem described in our notes on agentic workflow wiring patterns and pitfalls: when multiple agents run at once, you need visibility so none of them silently stall.
Use Spaces to preserve project context
Spaces group everything related to a task or project into one view:
- Agent sessions
- Pull requests
- Files
- Project context
Use a Space when you want several agents to work from the same context.
Example workflow:
- Create a Space for a feature, bug, or service.
- Add the relevant files and sessions.
- Start new agents inside that Space.
- Let each session inherit the existing project context.
- Return later and continue from the same view.
The benefit is reduced repetition. Instead of explaining the same codebase and task constraints to every agent, you keep context in the Space and start sessions from there.
Run parallel agents deliberately
The Command Center and Spaces are designed for parallel agent work. Cognition’s new workflow assumes one engineer may run many agents across local and cloud environments.
A useful pattern:
- Use local agents for interactive edits and fast iteration.
- Use cloud agents for longer-running, well-scoped tasks.
- Use Spaces to keep related sessions grouped.
- Use PR review as the checkpoint before merging generated work.
This changes the developer’s role from “write every line” to “define the work, review the output, and merge what passes.”
Devin Local replaces Cascade
Cascade, the local interactive agent from Windsurf, is now legacy. The replacement is Devin Local, rewritten from scratch in Rust.
Cognition says Devin Local is:
- Up to 30% more token-efficient
- Built with support for subagents
- The new default after July 1
Token efficiency matters because agent workflows scale usage quickly. A 30% reduction compounds across many runs in a day. For the cost mechanics, see our guide on reducing agent token costs from the CLI.
You can keep using legacy Cascade through July 1. After that, Devin Local becomes the default.
Use Devin Cloud for delegated implementation
Devin Cloud is the autonomous agent, now connected directly to the editor.
Use it when a task is:
- Clearly scoped
- Long-running
- Easy to validate through tests or review
- Suitable for a pull request
The workflow is:
- Plan the change locally.
- Dispatch the task to Devin Cloud.
- Devin Cloud runs in an isolated VM with browser, shell, and editor access.
- It works independently while you continue elsewhere.
- It returns a pull request for review.
The handoff is the key feature. You stay in the editor for planning and review, while the cloud agent handles implementation.
Use Devin Review to close the PR loop
Devin Review keeps the review workflow inside Devin.
A typical loop:
- Devin Cloud returns a PR.
- You review it inside Devin.
- If needed, hand fixes back to a local agent.
- Approve the PR.
- GitHub auto-merge lands it once checks pass.
That reduces context switching between the editor, GitHub, and agent sessions.
Agent Client Protocol: run Codex, Claude, OpenCode, or custom agents inside Devin
Devin Desktop includes the Agent Client Protocol (ACP), an open-source standard for running compatible agents inside compatible editors.
At launch, Devin supports:
- Codex
- Claude Agent
- OpenCode
- Custom in-house agents
That means Devin is not limited to Cognition’s own agent. You can run multiple vendors’ agents side by side in the Command Center.
For more background on how agent runtimes are structured, read our breakdown of coding-agent harness architecture.
SWE-1.6, Cognition’s in-house model
Devin still supports frontier models from OpenAI, Anthropic, and Google. It also includes Cognition’s own SWE-1.6, free to use on paid plans.
The SWE model family is built for speed. The previous SWE-1.5 model ran at roughly 950 tokens per second, which helps fast inline edits and Tab completion feel responsive.
For day-to-day agentic edits, a fast in-house model can reduce reliance on frontier-model quota.
DeepWiki and code search
Devin auto-indexes repositories and generates a wiki for each one through DeepWiki.
The generated project wiki can include:
- Architecture diagrams
- Codebase summaries
- Links back to source files
New agents can read this index instead of crawling the repository from scratch. That is especially useful when starting sessions inside a Space, because the agent begins with useful context instead of a blank slate.
Integrations, the Sessions API, and Auto-Triage
Devin can start work from tools your team already uses:
- Slack
- Jira
- Linear
- GitHub
- Teams
- API calls
Important implementation details:
- Sessions API: fetch a session by ID, send messages to an active session, and filter sessions by origin such as webapp, Slack, Teams, API, Linear, or Jira.
- Session-scoped secrets: pass scoped secrets when creating a session so automated runs get credentials without pasting keys into prompts. Our guide on scoped secret access for coding agents explains why that matters.
- MCP support: Devin honors your default platform across session-creation methods. Its MCP OAuth flow now forwards the RFC 8707 resource parameter, which fixes auth for servers like Snowflake that require resource indicators.
- Auto-Triage: Devin can pick up incoming issues and start triage sessions automatically.
-
Slack control: type
!channel #nameto redirect where Devin posts a session’s response thread.
Install Devin CLI, JetBrains support, and desktop apps
Devin now spans more than the Desktop IDE.
Install the CLI:
curl -fsSL https://cli.devin.ai/install.sh | bash
Other supported surfaces include:
- JetBrains plugin: IntelliJ, PyCharm, WebStorm, GoLand, RubyMine, Rider, and other JetBrains IDEs.
- Desktop apps: macOS Apple Silicon, macOS Intel, Windows 10 64-bit, and Linux.
- Devin Next Beta: early-adopter track for newer changes.
How the new Devin compares to Cursor
The old comparison was simple:
- Cursor was the editor you drove directly.
- Devin was the autonomous agent you delegated to.
That distinction is less clean now. Devin is also an editor, and both tools can use multiple model vendors. The real difference is workflow posture.
| Cursor | Devin | |
|---|---|---|
| Default posture | You drive; AI assists inline | You drive locally, then delegate to the cloud |
| Human in the loop | Continuous | Intermittent; checkpoints and PR review |
| Multi-agent view | Limited | Agent Command Center, dozens in parallel |
| Autonomous cloud agent | Not bundled | Devin Cloud, isolated VM, returns PRs |
| Open agent protocol | Cursor-native | ACP; Codex, Claude Agent, OpenCode, custom |
| Best for | Exploration, UI iteration, evolving tasks | Well-defined, parallelizable, long-running work |
Their pricing ladders are now similar:
| Tier | Devin | Cursor |
|---|---|---|
| Free | Free; unlimited Tab and inline edits | Hobby; free, limited usage |
| Entry paid | Pro, $20/mo; cloud agent access | Pro, $20/mo |
| Power user | Max, $200/mo | Ultra, $200/mo |
| Teams | $80/mo + $40/seat | $40/user/mo |
| Enterprise | Custom | Custom |
One caveat: both tools meter heavy usage. Devin Cloud’s autonomous runs are the expensive part, so model your expected consumption before committing. Check Devin’s pricing and Cursor’s pricing docs for current numbers.
Be careful with raw benchmark comparisons. Cursor reports Composer 2.5 at 79.8% on SWE-bench Multilingual, while Devin’s autonomous mode has been measured around 45.8% on the stricter SWE-bench Verified. These are different benchmark suites with different rules, so they are not a clean scoreboard. See SWE-bench for details.
Since both editors can run frontier models, the deciding factor is workflow. For a model-focused comparison, see our Composer 2.5 vs Opus 4.7 vs GPT-5.5 comparison and the Composer 2.5 guide.
The short version:
- Pick Cursor if you want a focused, hands-on editor workflow.
- Pick Devin if you want an editor plus autonomous cloud work, multi-agent management, PR review, and ACP-based agent interoperability.
Where Apidog fits
Devin can generate code, but you still need to validate the APIs that code exposes.
Agents can scaffold routes, refactor services, and open PRs, but they do not automatically guarantee that:
- The API contract is correct
- Responses match expectations
- Dependencies are mockable
- Staging failures are easy to debug
- Frontend teams have stable endpoints to build against
Apidog handles that layer.
A practical agent-friendly API workflow:
- Design the API contract first in Apidog.
- Export or share the OpenAPI spec.
- Give the spec to Devin, Cursor, or another coding agent.
- Let the agent implement against a clear target.
- Test the generated endpoints in Apidog.
- Mock dependencies for frontend or integration work.
- Debug failed calls by inspecting requests and responses.
Spec-first development works well with autonomous agents because the contract gives the agent a precise target. Vague requirements are where agents tend to drift.
For implementation details, read the Apidog spec-first mode guide. For agent handoff structure, see what a design.md does for coding agents. When you need to inspect what an agent actually sends and receives, Apidog’s AI agent debugger helps analyze the traffic.
FAQ
Is Windsurf discontinued?
No. Windsurf is now Devin Desktop. It arrives as an over-the-air update, and your plan, settings, and extensions carry over unchanged.
What happened to Cascade?
Cascade is now legacy. Its successor is Devin Local, rewritten in Rust, up to 30% more token-efficient, and supports subagents. You can keep using Cascade through July 1.
Can Devin run Claude or Codex instead of its own model?
Yes. Through Agent Client Protocol, Devin Desktop can run Codex, Claude Agent, OpenCode, and custom agents alongside Cognition’s SWE-1.6 and other frontier models.
Is Devin free?
There is a free tier with unlimited Tab completions and inline edits. Access to Devin Cloud’s autonomous agents starts on the $20 Pro plan.
Is Devin better than Cursor?
It depends on workflow. Cursor is tighter for hands-on, in-editor development. Devin covers more surfaces: an IDE, autonomous cloud agent, multi-agent Command Center, review workflow, and ACP support.
How do I install Devin?
Download the desktop build from the download page, add the JetBrains plugin, or install the CLI:
curl -fsSL https://cli.devin.ai/install.sh | bash
The bottom line
The Windsurf rebrand is not only cosmetic. Devin is now a full IDE, an autonomous cloud agent, a CLI, and a review surface connected by the Agent Command Center and Agent Client Protocol.
Use it when you want to direct multiple agents, delegate long-running work, and review PRs instead of typing every line yourself.
Whichever coding tool you choose, keep your API contract testable. Design, mock, debug, and validate it in Apidog before agent-generated code reaches production.
Top comments (0)