Windsurf 2.0: Agent Command Center, Spaces & What the Devin Integration Actually Changes

Windsurf 2.0 shipped on April 15, 2026, and the changelog reads like a quiet architectural shift rather than a feature release. The IDE you used last month had one agent surface: the Cascade panel on the right. The IDE you have now has three: a Kanban for all your concurrent sessions, a Spaces layer that bundles context around tasks, and a one-click bridge to Devin running on a cloud VM. Each feature individually is useful. Together, they move Windsurf from "IDE with an AI panel" to something closer to a work-management layer for agent-assisted development.

This post covers what shipped, what it actually changes in practice, and how to rewire your workflow to get value from it starting today.

What actually shipped

The 2.0 release was built on top of Cognition AI's acquisition of Windsurf's parent company. That context matters: the strategic bet is that local IDE work and cloud agent work are complementary, not competing. You plan locally with full codebase context; you execute at scale in the cloud where a VM can run tests, open browsers, and keep working after you close your laptop.

Three things shipped together: the Agent Command Center, Spaces, and native Devin integration. All three are live for Pro, Max, and Teams plans. Enterprise requires admin enablement plus a separate Cognition Platform purchase. Free plan users see the UI but cannot run Devin sessions.

Agent Command Center

Before 2.0, if you had three Cascade sessions running across different branches, you navigated between them by clicking through tabs. There was no consolidated view of what each session was doing, what it had completed, or what was waiting on you.

The Agent Command Center is a Kanban-style panel that surfaces every active session — local Cascade sessions and cloud Devin sessions — in one view, grouped by status: running, waiting for review, blocked, done. You can switch into any session from this panel, see its last action at a glance, and hand off or kill it without leaving the view.

The practical delta: you stop losing context on background sessions. Previously, a Cascade session you hadn't touched in two hours was effectively gone — you'd forgotten where it was, what it was doing, whether it had finished. The Command Center brings that surface area back into a single glance.

Spaces: context that persists

Spaces is the feature that takes the most explaining, because it solves a problem that's easy to underfeel until you've hit it a dozen times.

The problem: every new Cascade session starts cold. You open a session for the authentication refactor, spend the first ten turns re-explaining the codebase conventions, the relevant files, and the design decisions already made. Next day, new session, same ten turns. Multiply by five ongoing workstreams and you're spending a non-trivial fraction of your AI budget re-seeding context that doesn't change.

A Space bundles an agent session (or multiple sessions) with a persistent context payload: relevant files, open PRs, design docs, previous agent outputs, and any custom instructions specific to that workstream. When you create a new session inside a Space, it inherits all of that. When you return to a Space after three days, the view is exactly as you left it.

# .windsurf/spaces/auth-refactor.yml
name: auth-refactor
description: JWT → OAuth migration — Q2 2026

context:
  files:
    - src/auth/**
    - docs/adr/0012-oauth-migration.md
  pull_requests:
    - "#847"
    - "#851"
  notes: |
    We're keeping the JWT middleware for mobile clients until
    v4.2 ships. Do not touch src/auth/mobile-compat.ts.

agents:
  - cascade          # local session
  - devin            # cloud session for longer-running tasks

The feature is particularly useful for long-running workstreams — the kind that span a week or more and involve multiple sessions, multiple PRs, and decisions that a fresh context window has no way to reconstruct. Spaces make those workstreams first-class citizens instead of things you carry in your head.

Devin: local plan, cloud execute

The Devin integration is the one that will divide opinion the most, because it requires trusting an agent with work you can't directly observe in real time.

The mechanic is straightforward: you plan work locally with Cascade, where you have full codebase context and can iterate quickly. When the spec is solid and the approach is decided, you hand off to Devin with one click. Devin picks up the task on its own VM — complete with a browser, terminal, and desktop environment — runs the implementation, debugging, and testing loop, and surfaces a completed PR back in your Space when done.

The VM isolation matters for longer-running tasks. Devin can run a full test suite that takes 40 minutes. It can open a browser, test a UI flow, screenshot failures, and loop. It keeps working after you close your laptop. None of that is practical with a local Cascade session that blocks on your machine.

Devin is included in all self-serve plans (Pro, Max, Teams) and draws from the same shared Windsurf usage quota. There's no separate billing line item at the self-serve tier. New accounts that connect a GitHub organization receive up to $50 in additional usage credits, which covers several full Devin sessions for medium-complexity tasks.

Pricing changes

Windsurf 2.0 landed alongside a pricing restructure. The old Pro plan at $15/month moved to $20/month. A new Max plan at $200/month was introduced for teams doing high-volume agent work. The price increase on Pro is worth examining: Devin sessions are expensive to run (cloud VM time is not free), and folding them into the base Pro plan required raising the floor.

The Max plan at $200/month positions Windsurf against Cursor's Pro tier and the upper range of Claude Code's Max plan pricing. If your team is running multiple Devin sessions per day, the math works out reasonably — individual Devin task credits on the open market would exceed this quickly. If you're running one session per week, Pro is probably enough.

Rethinking your workflow

The features only pay off if you actually change how you work. Three workflow adjustments make the biggest difference:

1. Create a Space before you start a workstream, not after

The instinct is to create a Space once you realize you need persistent context. By then you've already rebuilt it from scratch twice. Treat Space creation as the first action when starting anything that will last more than one session. Seed it with the relevant files, the ADR or design doc, and any constraints the agent needs to know up front.

2. Let the Command Center replace your mental queue

Before 2.0, developers were keeping a mental list of "sessions I started that might be done." That's cognitive overhead with no upside. Open the Command Center at the start of your day, triage what's waiting for review, and start new sessions from there. Treat it as your actual task queue, not a bonus panel.

3. Write specs for Devin, not instructions

Cascade is conversational — you can course-correct mid-task. Devin executes in the cloud and returns a PR. That means the quality of the output is almost entirely determined by the quality of the spec you hand off. Before handing to Devin, write a checklist: what files should change, what should not change, what tests need to pass, and what the acceptance criteria are. A vague handoff returns a vague PR.

## Task: add rate-limit middleware to /api/v1/auth endpoints

### Scope
- Add middleware in src/middleware/rate-limit.ts (create new file)
- Apply to all routes in src/routes/auth.ts
- Do NOT modify src/auth/mobile-compat.ts (mobile client freeze)

### Requirements
- 10 req/min per IP for POST /login and POST /register
- 100 req/min per IP for all other auth routes
- Return 429 with Retry-After header on limit exceeded
- Use Redis for state (client already in src/lib/redis.ts)

### Acceptance criteria
- [ ] All existing auth tests pass
- [ ] New rate-limit tests added covering 429 path
- [ ] No changes to mobile-compat.ts
- [ ] pnpm lint passes

Skills for Windsurf 2.0

On skills-hub.ai/windsurf-skills, the catalog includes several skills designed for the 2.0 workflow: context-seeding skills that auto-populate a new Space with the right files and conventions, Devin handoff spec generators, and review skills that run against the diff Devin returns before you merge. Browse productivity skills for the Windsurf-specific entries, or install the new windsurf-spaces skill directly:

# install the windsurf-spaces skill (sets up and seeds Spaces from project context)
npx @skills-hub-ai/cli install windsurf-spaces

# install the devin-handoff-spec skill (generates structured Devin task specs)
npx @skills-hub-ai/cli install devin-handoff-spec

The shift Windsurf 2.0 represents is worth naming clearly: the IDE is no longer the unit of work, the workstream is. Spaces, Devin, and the Command Center all reinforce that framing. If you adopt it, the tools make sense. If you keep treating the IDE as a fancy editor with an AI panel, most of the new surface area will go unused.

The three features don't make this shift for you, but they do remove the tooling friction that made it hard. The rest is habit.