Move your team from Windsurf to Cursor.
Each person gets a short interview, then a personalized step-by-step guide showing exactly where their saved work, prompts, and projects land in Cursor — and the few things that need a manual step, walked through. You send one invite; nobody becomes the help desk, and nothing in Windsurf is changed or cancelled. Want to see where you’re paying for both first? Run the free audit.
Map Cascade (Windsurf's in-IDE agent, now rebranded Devin Local in Devin Desktop, opened in the Cascade panel) to Cursor's Agent in the Agents Window (Cmd/Ctrl+I). Both run an agentic loop that edits files, searches the codebase, executes terminal commands, and streams diffs for review. Cascade's named checkpoints/snapshots and per-prompt revert map to Cursor's automatic agent checkpoints ('restore' reverts all files to a prior snapshot). Cascade's two modes are Code (edits) and Chat (read-only Q&A); plus a built-in planning capability (a specialized planning agent that auto-creates a to-do plan for long tasks — automatic, not a manual toggle). These map to Cursor's mode picker (rotate with Shift+Tab): Code → Agent mode, Chat → Ask mode, and Cursor's explicit Plan mode covers the up-front-plan use case. Multiple simultaneous Cascades (dropdown navigation, worktrees for same-file isolation) map to Cursor's parallel agents on git worktrees in the Agents Window. Timing matters: Windsurf became Devin Desktop on 2026-06-02 and the legacy Cascade agent is end-of-life on 2026-07-01, replaced by Devin Local — if you are leaving rather than migrating to Devin Local, move before workflows hard-break.
- Warning: Cascade's 'real-time awareness' (it watches your recent editor actions in real time to infer intent without re-prompting) has no Cursor equivalent — in Cursor you must @-mention or select the context you want the agent to see.
- Warning: Cascade's 20-tool-calls-per-prompt cap with the 'Continue' button (each continue consumes another prompt credit) does not exist in Cursor; Cursor agents run until done and bill by token usage instead.
- Warning: Cascade prompt reverts are irreversible per the docs; Cursor checkpoints let you preview the snapshot before restoring.
- Warning: Cascade conversation sharing and @-mentions of prior conversations are Teams/Enterprise-only in Windsurf; Cursor agent history is local to the workspace with no direct conversation-share primitive.
- Warning: Anything you scripted against Cascade specifically (CI invocations, hooks that key on Cascade behavior) dies with the 2026-07-01 EOL regardless of which way you migrate.
Devin cloud (each session on its own VM with desktop, browser, and computer use; keeps working after you close the laptop; managed via the Agent Command Center kanban + Spaces) maps to Cursor Cloud Agents (isolated VMs with cloned repo, dependencies, and network access). Trigger-surface parity is good: Devin launches from the editor with one-click plan handoff from Cascade; Cursor Cloud Agents launch from the editor's Cloud dropdown, cursor.com/agents on the web, Slack (@cursor), GitHub PR/issue comments, Linear, or API. Both deliver work for review — Cursor's agents produce merge-ready PRs with demo artifacts (screenshots, videos, logs). Configure the Cursor environment via `.cursor/environment.json` (agent-led setup, snapshot, or Dockerfile) to replicate what Devin's VM gave you for free.
- Warning: Devin's VM includes a full desktop and browser with computer use; Cursor Cloud Agents are development-environment VMs — workflows that relied on Devin driving a GUI/browser beyond testing do not carry over one-to-one.
- Warning: Cursor Cloud Agents always run in Max Mode billed at API pricing with spend limits you set on first use; Devin consumes the Windsurf plan's shared quota/extra-usage balance — the cost model changes from quota-draw to metered API spend.
- Warning: The one-click 'Cascade plans locally, Devin implements in the cloud' handoff is a Windsurf-native flow; in Cursor you explicitly dispatch the cloud agent with its own prompt.
- Warning: Devin's $50 GitHub-connect extra-usage credit and Agent Command Center organization (Spaces bundling sessions/PRs/files) have no Cursor equivalents.
Both products maintain an automatic local index of the codebase, so the core experience carries over with no migration work: Windsurf's RAG-based M-Query retrieval (Fast Context) corresponds to Cursor's custom-embedding semantic index (built on workspace open, usable at 80% completion, re-synced every 5 minutes). Port your exclusions: `.windsurfignore` / `.codeiumignore` patterns go into `.cursorignore` (Cursor also respects `.gitignore`). Windsurf's pinned context items (files/folders/modules promoted for retrieval priority) approximate to Cursor's explicit @-symbols (@file, @folder, @Code) plus always-applied rules pointing at canonical files. Team-tier features map too: Windsurf remote repository indexing (Teams/Enterprise) ≈ Cursor team-shared indexes.
- Warning: Pinning has no exact Cursor equivalent — Windsurf pins bias retrieval persistently; in Cursor you either @-mention per conversation or encode 'always look here' guidance in a rule.
- Warning: Windsurf's Knowledge Base integration (up to 50 Google Docs as team context, Teams/Enterprise beta) has no Cursor counterpart; Cursor's @Docs indexes public documentation sites, not private Google Docs.
- Warning: Index depth is plan-gated differently: Windsurf expands context lengths and indexing limits on Pro; Cursor's indexing is not metered by plan but indexed codebases are deleted after 6 weeks of inactivity.
- Warning: Cursor disables some single-git-root features (e.g. worktrees) in multi-root workspaces, and Cloud Agents don't support multi-root at all — relevant if your Windsurf workspace was multi-root.
Windsurf (Devin Desktop) and Cursor are both VS Code forks, so the editor shell migrates almost free: themes, keybindings, and settings.json are VS Code-shaped on both sides, and extensions install from Open VSX in both. Use Cursor's import-from-VS-Code flow where it detects your profile, or manually copy `settings.json`/`keybindings.json` and reinstall extensions. Per the Cursor forum, there is no first-party Windsurf→Cursor migration guide — but because the config surfaces are VS Code-compatible, the manual path is short.
- Warning: Windsurf's plugin family is the real loss: JetBrains (the only plugin with full Cascade support), Vim/Neovim, Visual Studio, Jupyter, Chrome/Colab, and Eclipse plugins have NO Cursor counterpart — Cursor is editor+CLI only. JetBrains-first developers cannot replicate their Windsurf setup in Cursor at all.
- Warning: Most Windsurf plugins were already in maintenance mode (autocomplete/chat/command only, no Cascade), so for plugin users the migration delta is smaller than it looks — they were never getting the agent anyway.
- Warning: Windsurf-specific settings (Cascade panel config, auto-execution tiers, MCP marketplace state) live outside standard VS Code settings and do not import; redo them in Cursor's own settings UI.
- Warning: Both forks lag or lack some Microsoft-proprietary extensions (Pylance, Remote-SSH variants); moving between forks doesn't fix that, but verify your critical extensions exist on Open VSX before committing.
Cascade Hooks translate cleanly to Cursor hooks: both are JSON-configured shell commands that receive event context as JSON on stdin and block actions by exiting with code 2. Move configs from Windsurf's three merged levels (system `/etc/windsurf/hooks.json` etc., user `~/.codeium/windsurf/hooks.json`, workspace `.windsurf/hooks.json`) to Cursor's `hooks.json` levels (enterprise, team, project `.cursor/hooks.json`, user `~/.cursor/hooks.json`). Event mapping: `pre_run_command`/`post_run_command` → `beforeShellExecution`/`afterShellExecution`; `pre_mcp_tool_use`/`post_mcp_tool_use` → `beforeMCPExecution`/`afterMCPExecution`; `pre_read_code` → `beforeReadFile`; `post_write_code` → `afterFileEdit`; `pre_user_prompt` → `beforeSubmitPrompt`; `post_cascade_response` → `stop` / `afterAgentResponse`; generic pre/post tool events → `preToolUse`/`postToolUse`.
- Warning: The stdin JSON payload schemas are completely different (Windsurf sends `agent_action_name`, `trajectory_id`, `tool_info`; Cursor sends `conversation_id`, `generation_id`, `hook_event_name`, plus permission-response JSON on stdout) — every hook script's parsing must be rewritten, only the trigger logic survives.
- Warning: Windsurf's `post_setup_worktree` event has no direct Cursor equivalent; `workspaceOpen` is the closest app-lifecycle hook.
- Warning: Windsurf hooks declare a separate `powershell` command field for Windows; Cursor hooks are scripts in any language but you handle cross-platform shims yourself.
- Warning: Windsurf merges all three config levels; Cursor applies priority order (enterprise → team → project → user) — semantics of conflicting hooks differ.
Near copy-paste migration. Windsurf stores MCP servers in `~/.codeium/windsurf/mcp_config.json` under an `mcpServers` object; Cursor reads the same `mcpServers` shape from `~/.cursor/mcp.json` (global) or `.cursor/mcp.json` (project). For stdio servers, copy `command`/`args`/`env` entries verbatim. For remote servers, rename Windsurf's `serverUrl` key to Cursor's `url`. Environment-variable interpolation carries over: `${env:VAR_NAME}` works identically in both products. Both support stdio, Streamable HTTP, and SSE transports with OAuth. Re-add marketplace-installed servers via Cursor's one-click MCP marketplace instead of hand-porting their JSON.
- Warning: Windsurf's `${file:/path}` interpolation (reading secrets from files) has no Cursor equivalent — move file-based secrets into environment variables before porting.
- Warning: Windsurf's `windsurf://windsurf-mcp-registry?serverName=...` deeplinks are dead ends in Cursor; equivalent one-click installs use Cursor's marketplace/deeplink format.
- Warning: Cascade caps total accessible MCP tools at 100 across all servers; Cursor has no documented hard cap but project-scoped `.cursor/mcp.json` gives you per-repo scoping Windsurf's single global file lacks — restructure global configs into project files where appropriate.
- Warning: OAuth-authenticated servers must re-authenticate after migration; tokens do not transfer.
- Warning: Enterprise controls differ: Windsurf admins whitelist servers (including regex) via the Admin Portal; Cursor's enterprise MCP management uses its own mechanism — admin policies must be rebuilt, not copied.
Both products are multi-vendor model pickers, so day-to-day habits survive: a Windsurf user on Claude Opus 4.8 / Sonnet 4.6, GPT-5.5, or Gemini 3.1 Pro selects the same family in Cursor's model dropdown. The in-house economy models map conceptually: Windsurf's SWE-1.6 (0-credit) / SWE-1.5 and Arena tiers (Fast 1x / Hybrid 1.5x / Frontier 2x) correspond to Cursor's Composer 2.5 and Auto mode, which draw from a generous dedicated usage pool rather than API-rate billing. Windsurf's 'Adaptive' auto-routing corresponds to Cursor's Auto. Billing mental model translation: Windsurf prices everything in credit multipliers (0x to ~450x); Cursor splits usage into an Auto/Composer pool (cheap, generous) and an API pool billed at each model's standard API rates.
- Warning: SWE-series models are Windsurf-exclusive; Composer 2.5 is Cursor-exclusive — both sides' cheapest agentic models are non-portable, and their behavior differs.
- Warning: Windsurf documents no customer-facing BYOK; Cursor supports API keys for external providers but BYOK never covers Tab or Cursor-subsidized pool pricing.
- Warning: Effort-variant naming differs: Windsurf sells Claude Opus 4.8 as separate Low/Medium/High/XHigh picker entries with different multipliers; Cursor exposes thinking/fast variants and Max Mode (full context window) instead.
- Warning: Cost comparison is genuinely hard: a 25x Windsurf multiplier and a Cursor API-pool token rate are different units — model your actual monthly usage rather than comparing list prices.
- Windsurf gates the full model catalog behind Max/Enterprise (Pro gets a subset); Cursor's model list is plan-independent but spend comes out of differently-sized included-usage pools.
Windsurf Rules convert mechanically to Cursor Rules. Workspace rules in `.windsurf/rules/*.md` (or the newer `.devin/rules/*.md`) become `.cursor/rules/*.mdc` files; translate the `trigger` frontmatter: `always_on` → `alwaysApply: true`, `glob: <pattern>` → `globs: <pattern>`, `model_decision` → a description-only rule the agent applies intelligently, `manual` → a manual rule invoked by @-mention. Global rules (`~/.codeium/windsurf/memories/global_rules.md`) become Cursor User Rules. The cheapest path: both products read `AGENTS.md` natively — if your Windsurf rules already live in AGENTS.md (root always-on, subdirectory files auto-scoped), Cursor picks them up with zero conversion, including nested AGENTS.md files. Community tooling like rule-porter (github.com/nedcodes-ok/rule-porter) automates the cross-format conversion.
- Warning: Auto-generated Memories do NOT migrate: they live in `~/.codeium/windsurf/memories/`, are workspace-specific, machine-local, and Cursor has no auto-memory system at all. Before leaving, read your memories and hand-promote anything load-bearing into a rule or AGENTS.md entry.
- Warning: Size limits differ: Windsurf enforces 6,000 chars (global) / 12,000 chars (workspace rule); Cursor only recommends keeping rules under ~500 lines — long rules port without truncation but adherence degrades.
- Warning: Cursor rules apply only to Agent (chat); they do not influence Tab autocomplete or Inline Edit. Windsurf users who relied on rules shaping completions lose that.
- Warning: Legacy single-file `.windsurfrules` and legacy `.cursorrules` are both deprecated formats; convert to the directory-based forms rather than translating legacy-to-legacy.
Tier-for-tier mapping for a migrating individual: Windsurf Free → Cursor Hobby (both $0); Windsurf Pro $20/mo → Cursor Pro $20/mo (with $20 included API usage); Windsurf Max $200/mo → Cursor Ultra $200/mo ($400 included API usage), with Cursor Pro+ $60/mo ($70 included) as an intermediate stop that Windsurf lacks. Teams: Windsurf Teams ($80/mo base + $40/user) → Cursor Teams Standard $40/user (no base fee) or Premium $120/user. Meter shape translation: since the 2026-03-19 overhaul Windsurf uses daily/weekly auto-refreshing usage quotas with extra usage billed at API pricing; Cursor uses monthly pools (Auto/Composer pool plus an API-rate pool equal to the included-usage dollar amount) with pay-as-you-go overage at the same API rates.
- Warning: Quota cadence differs materially: Windsurf's allowance refreshes daily AND weekly (bad weeks self-heal), Cursor's pools reset monthly (a heavy week can exhaust the month).
- Warning: Windsurf Pro includes the Devin cloud agent in-plan; Cursor's closest analog (Cloud Agents) bills as Max-Mode API usage rather than being a quota line item — heavy background-agent users should price this explicitly.
- Warning: The June 2026 Devin Desktop rebrand kept Windsurf pricing unchanged ('plan, pricing, extensions remain the same'), and the FAQ confirms legacy credit-model Enterprise accounts continue exactly as before (prompt-based credits still consumed) — so what you migrate FROM may not match the current public page; check the actual account, not the pricing page.
- Warning: Cursor Teams adds a $0.25/M-token Cursor Token Rate on non-Auto requests — no Windsurf equivalent; factor it into team cost models.
Windsurf Workflows (`.windsurf/workflows/<name>.md`, invoked via `/<name>`) become Cursor skills: create `.cursor/skills/<name>/SKILL.md`, paste the workflow's step content as the body, and put the title/description into frontmatter. Cursor merged its older custom slash commands into skills, and `/[name]` invocation works the same way, so the user-facing trigger is unchanged. Global workflows (`~/.codeium/windsurf/global_workflows/`) become user-level skills. Cursor ships a `/migrate-to-skills` helper that converts its own legacy commands — Windsurf workflows themselves are a manual copy, but the format distance is small (both are plain Markdown instructions).
- Warning: Windsurf workflows are strictly manual-only (Cascade never auto-invokes them); Cursor skills can be auto-loaded by the agent when deemed relevant — set the skill's invocation control to explicit/manual if you want the old contract preserved.
- Warning: Workflow composition (a workflow invoking `/other-workflow` as a step) is a Windsurf-documented feature; in Cursor, restructure nested calls as instructions referencing the other skill, and verify the chained behavior by hand.
- Warning: Windsurf's 12,000-character-per-file limit disappears in Cursor, but Windsurf's enterprise system-level workflow directories (`/etc/windsurf/workflows/` etc.) map to Cursor Team Rules/team-distributed content rather than a files-on-disk convention.
- Warning: Windsurf's built-in workflow templates (e.g. `/plan`) don't exist in Cursor; Cursor's Plan mode covers the planning use case natively.
Direct feature-for-feature counterpart with nothing to migrate — both are proprietary in-house completion models with no exportable config. Windsurf Tab's two modes (Supercomplete multi-line diff suggestions, classic Autocomplete) correspond to Cursor Tab's multi-line edits; Tab to Jump (cursor-position prediction) corresponds to Cursor Tab's jump-in-file and cross-file portal; Tab to Import corresponds to Cursor Tab adding missing import statements. Word-by-word acceptance exists on both (Cursor: Cmd/Ctrl+ArrowRight partial accept). Both are effectively unlimited: Windsurf Tab is unlimited on every plan including Free; Cursor includes unlimited tab completions on all paid plans.
- Warning: Windsurf's opt-in clipboard context for completions has no documented Cursor equivalent — Cursor Tab draws on recent edits, surrounding code, and linter errors instead.
- Warning: Neither product's Tab model is swappable or BYOK-able; behavior differences are model differences and cannot be tuned back.
- Warning: Cursor rules do not shape Tab output, and Windsurf rules don't shape its Tab either — but Windsurf Tab reads terminal activity and Cascade chat history as context, which Cursor Tab does not advertise.
- Warning: On Cursor's free Hobby tier Tab is limited, whereas Windsurf Free has unlimited Tab — downgrade-path users notice this.
Both products generate terminal commands from natural language (Cmd/Ctrl+I in Windsurf's Command mode; Cmd/Ctrl+K in Cursor's terminal) and let the agent execute commands with configurable autonomy. Map Windsurf's four auto-execution tiers onto Cursor's run modes: Disabled → Cursor Allowlist mode with an empty allowlist (everything reviewed); Allowlist Only → Cursor Allowlist / Allowlist-with-Sandbox modes; Auto (model judges safety) → Cursor Auto-review (default: allowlisted commands run, others run sandboxed or get LLM-classifier review); Turbo → Cursor Run Everything. Recreate your allow/deny command lists in Cursor's settings — the concept carries over directly, including admin-enforced org-wide lists on team tiers.
- Warning: Cursor adds an OS-level sandbox layer (workspace-scoped file access, network blocked by default, configurable via sandbox.json) that Windsurf's tier system does not have — commands that 'just worked' under Windsurf Auto may fail under Cursor's sandbox until you allow domains/paths.
- Warning: Cursor's sandbox has platform requirements (macOS v2.0+, Windows requires WSL2, Linux kernel 6.2+ with Landlock v3); Windows-without-WSL2 users don't get sandboxed execution.
- Warning: Windsurf's Auto tier is premium-models-only; Cursor's Auto-review classifier is plan-independent.
- Warning: Windsurf's macOS Cascade uses a dedicated zsh shell separate from your default terminal (with .zshrc support); Cursor executes in its integrated terminal context — environment-dependent scripts may behave differently.
- Deny-list precedence: both honor deny over allow, but Windsurf org lists override individual settings wholesale on Teams/Enterprise; verify Cursor enterprise admin overrides match your policy before rollout.