What Is Windsurf Wave 10? A Multi-Day Release Explained

Windsurf Wave 10 is a multi-day product release from Codeium (now part of Cognition AI) that launched on June 10, 2025, delivering the company’s most ambitious set of agentic features to date. Unlike previous waves that shipped single improvements, Wave 10 rolled out over at least two days: Day 1 introduced Planning Mode for structured long-horizon task management, and Day 2 introduced the Windsurf Browser — a Chromium-based browser embedded directly inside the IDE. The release also dropped the price of the o3 reasoning model from 10x credits to 1x credits, an effective 90% cost reduction that made high-reasoning inference practical for everyday use. Windsurf Wave 10 arrives at a moment of rapid market growth: by March 2026, Windsurf had reached 1M+ active users generating 70M+ lines of AI-written code per day, with 59% of Fortune 500 companies building on the platform. Wave 10 is the first Windsurf release after the Cognition AI acquisition in July 2025 — and it signals the direction Cognition is taking the product: toward persistent, browser-aware, fully agentic coding workflows.

Wave 10 is significant because it consolidates capabilities that developers previously had to cobble together using third-party tools like Taskmaster and Stagewise. Planning Mode effectively bakes Taskmaster-style task decomposition into Cascade itself, while the Windsurf Browser replaces the manual workflow of copying DOM snippets or console logs into the chat window. Both features reflect Windsurf’s broader thesis: AI coding assistants should handle context management so developers can focus on intent.

Planning Mode: How Cascade Manages Long-Horizon Tasks

Planning Mode is Windsurf’s solution to a problem every developer has hit: complex tasks that span multiple sessions lose context as conversations reset. Planning Mode works by attaching a persistent Markdown file — saved at ~/.windsurf/plans/ — to every Cascade conversation. When you switch from discussing a task to implementing it, Cascade reads the plan.md file to restore context, picks up where it left off, and tracks which steps are complete. Unlike in-chat task lists that vanish when you close the IDE, the plan.md file persists to disk. You can edit it manually between sessions, and Cascade will recognize your changes and adjust its actions accordingly. When you click “Implement” on a plan in the Windsurf UI, the IDE automatically switches from Planning Mode to Code mode, signaling Cascade to begin execution. Planning Mode is available on all paid Windsurf plans at no extra cost, with no per-session token charges for plan file reads.

The underlying model in Planning Mode is distinct from the Code mode model. In Planning Mode, Cascade runs a higher-reasoning pass to decompose your goal into steps, identify dependencies, and flag ambiguities before writing any code. This prevents the common failure pattern where an AI jumps straight into implementation only to discover a foundational assumption was wrong three hours into the task. Real developer reports confirm the productivity impact: one developer reported reaching an MVP prototype within 8 hours of enabling Planning Mode on a complex project, attributing the speed to Cascade’s ability to maintain task context without human re-briefing between sessions.

How to Enable and Use Planning Mode Step by Step

Enabling Planning Mode in Windsurf takes under thirty seconds and requires no configuration files. Open the Cascade chat panel, click the mode selector dropdown at the top of the chat interface (which defaults to “Write” mode), and select “Plan.” Cascade will immediately ask you to describe your task or goal. You describe the feature, bug, or system you want to build in plain English — there is no template to follow. Cascade then generates a plan.md file in ~/.windsurf/plans/ and displays it in the editor alongside the chat. The plan includes a summary of the goal, a numbered list of concrete steps, and a section for open questions or blockers Cascade needs you to answer before proceeding. You can edit any part of the plan.md directly — add steps, remove steps, reorder them, or rewrite the goal — and Cascade will re-read the file and adjust its understanding.

To execute the plan, click the “Implement” button that appears at the top of the plan.md file in the editor. Windsurf switches the mode selector back to “Write” automatically, and Cascade begins executing Step 1. As it completes each step, it updates the plan.md to mark steps done. If you close the IDE mid-execution and return later, you open the same plan.md file, resume the Cascade conversation, and Cascade reads the file to determine where it left off. You do not need to re-explain the task — the plan file is the shared memory.

Best practice from experienced users: keep plans to 10–15 steps for a single session. Shorter, iterative plans outperform ambitious 50-step roadmaps because they give you review checkpoints and reduce the blast radius if Cascade misinterprets a step early on.

Understanding the plan.md File: Your Shared Brain with Cascade

The plan.md file is a plain Markdown document that Windsurf treats as a first-class artifact — not a chat message, not a temporary buffer, but a file saved to your home directory that persists independently of any conversation. Its structure is intentionally simple: a title, a goal statement, a numbered list of implementation steps, and an optional “Open Questions” section where Cascade lists things it cannot resolve autonomously. Both you and Cascade can edit the file, and Windsurf monitors it for changes at the filesystem level — when you save a modified plan.md, Cascade’s next action will reflect your edits without you needing to paste the updated plan into chat.

The plan.md pattern solves a long-standing problem in AI-assisted development: context window exhaustion. When a multi-day project sprawls across dozens of Cascade conversations, each new conversation starts without memory of what was decided or implemented. The plan.md file serves as an external memory store that outlives individual context windows. Cascade reads it on each new conversation start, restoring a minimal but sufficient representation of task state. This is structurally similar to how experienced developers maintain a scratchpad or decision log when working on large features — except Cascade both writes and reads the log autonomously.

For effective plan.md usage: write the goal statement in one sentence before you let Cascade generate the steps. A vague goal produces vague steps. A goal like “Add Stripe webhook handling for subscription cancellation events and write three integration tests” gives Cascade enough specificity to generate executable steps on the first pass. Also: treat the Open Questions section seriously — Cascade puts blockers there when it genuinely cannot proceed without your input, and ignoring them will cause the implementation to stall.

Day 2 of Wave 10: Introducing the Windsurf Browser

The Windsurf Browser is a built-in Chromium-based browser launched on Day 2 of Wave 10, currently in beta for all self-serve plan users. It lives as a panel inside the Windsurf IDE — not a separate window — and integrates natively with Cascade. The core value proposition is context without copy-paste: Cascade can see which tabs you have open in the Windsurf Browser without you sharing any URLs or pasting any content. When you are debugging a frontend component, Cascade can observe the rendered page, the console logs, and the DOM simultaneously, treating all of it as context for the next action it takes. The Windsurf Browser supports both local development servers (localhost) and external sites, so you can point it at a production page, a competitor’s UI, or a design reference and give Cascade direct visual and structural access to what you are looking at.

For developers who have experienced the friction of iterating on a React component by pasting error messages into chat, the Windsurf Browser represents a qualitative shift. The workflow changes from: (1) see error, (2) copy error, (3) paste into chat, (4) get fix, (5) apply fix, (6) reload, to: (1) see error, (2) tell Cascade to fix it. Cascade reads the console, reads the DOM, identifies the problem, and applies the edit — all without you leaving the editor.

Browser-Aware Cascade in Practice: Console Logs, DOM, and Tab Context

Browser-aware Cascade means Cascade has read access to three layers of browser state simultaneously: the rendered page (what you see), the DOM structure (what the HTML tree looks like), and the console log output (what JavaScript is emitting). When you open the Windsurf Browser and navigate to your running app, Cascade can inspect all three layers without any manual action on your part. You can click on any element on the page to send it as context — selecting a broken layout component, a misfiring animation, or a table with wrong data immediately surfaces the relevant DOM node and its associated styles in Cascade’s context. For log-heavy debugging workflows, Cascade can watch the console in real time and surface patterns across multiple log lines — for example, identifying that a sequence of network errors always precedes a blank state render.

The component selection feature deserves specific attention for design-to-code workflows. When you open a reference design in the Windsurf Browser — a Figma export, a competitor’s UI, or a design system docs page — you can click a specific component, diagram, or text block to send it to Cascade as structured context. Cascade then has a concrete visual and DOM reference to target when it generates or modifies code, producing output that matches the reference rather than a generic approximation. For teams working from design specs, this eliminates a full round-trip: describe what you want → select it in the browser → Cascade implements it directly.

A practical note on scope: browser-aware context is opt-in per tab. Cascade will not automatically read every open tab you have in the Windsurf Browser without your direction. You direct Cascade’s attention by clicking on the tab, the element, or the log entry you want it to use. This keeps the context focused and prevents Cascade from being distracted by unrelated browser state.

o3 Model Pricing in Wave 10: From 10x Credits to 1x

One of the most immediately impactful changes in Wave 10 is the pricing change for Windsurf’s o3 model integration. Before Wave 10, using OpenAI’s o3 reasoning model through Cascade cost 10x the standard credit rate — meaning a single o3 call consumed as many credits as ten standard model calls. In Wave 10, Codeium reduced o3 pricing to 1x credits, a 90% cost reduction that puts the high-reasoning model on equal footing with standard models from a budgeting perspective. This matters because o3 is Windsurf’s strongest model for complex reasoning tasks: architectural decisions, security analysis, algorithm design, and multi-file refactors where understanding dependencies across the codebase is critical.

At 10x credits, developers rationed o3 carefully — using it only for the most complex tasks and defaulting to cheaper models for everything else. At 1x credits, you can use o3 as your default model throughout a Planning Mode session without worrying about burning your monthly credit allocation. The practical implication: Planning Mode plus o3 at 1x is now the recommended stack for any task that spans more than a single session or involves system-level design decisions. The combination lets Cascade apply deep reasoning to plan generation and then execute with the same model — no model switching mid-task means more consistent behavior across the plan-to-implementation sequence.

For context on the competitive landscape: o3 at 1x in Windsurf positions it ahead of Cursor, which does not expose o3 natively in its credit system, and GitHub Copilot, which routes complex tasks through GPT-4o rather than o3 by default.

Windsurf Wave 10 vs Cursor: Planning and Browser Features Compared

Windsurf Wave 10 and Cursor represent two different philosophies on AI-assisted planning. Windsurf Wave 10 ships native Planning Mode with a persistent plan.md file, browser-native tab context, and o3 at 1x credits. Cursor offers its Composer feature for multi-file editing and has a Notes feature for saving snippets, but has no native planning mode that generates and tracks a persistent plan file across sessions. Cursor’s Browser integration as of early 2026 is limited to user-pasted URLs — Cursor cannot read the active tabs in a built-in browser the way Windsurf Browser does with Cascade. According to LogRocket’s February 2026 AI Dev Tool Power Rankings, Windsurf ranked #1 ahead of Cursor and GitHub Copilot, a shift from 2024 when Cursor held the top position.

The comparison shows Windsurf Wave 10 is ahead on the planning and browser-awareness dimensions. Where Cursor maintains an edge is in its established user base and VS Code-like keybindings that many developers find more familiar. JetBrains’ January 2026 survey shows GitHub Copilot at 29% workplace adoption, with Cursor and Claude Code tied at 18%, and Windsurf at ~8% — but Windsurf’s enterprise growth is accelerating, with 4,000+ enterprise customers by early 2026.

Real Developer Results: What Planning Mode Changes in Your Workflow

Developers using Planning Mode report two consistent improvements: faster onboarding on complex tasks and less context re-loading between sessions. The fastest-reported time from idea to MVP using Planning Mode is 8 hours — a developer used Cascade in Planning Mode to prototype a full core feature, crediting the plan file’s ability to maintain task state without human intervention between iterations. The pattern that emerges from multiple developer reports is that Planning Mode’s biggest value is not the plan itself but the reduction in “re-explaining overhead.” Every time you start a new Cascade conversation on a complex task without Planning Mode, you spend 5–15 minutes re-establishing context: what was built, what was decided, what the open questions are. Planning Mode eliminates that overhead by externalizing context into the plan.md file.

For solo developers working on long-running side projects, Planning Mode acts as a persistent scratchpad that both you and your AI assistant can read. For teams, plan.md files can be committed to version control and shared, giving teammates visibility into what Cascade is being asked to implement — a lightweight audit trail for AI-assisted development. For developers prone to context switching (jumping between features before finishing), Planning Mode applies gentle friction: the plan.md file makes it visible that Step 4 of the current plan is incomplete, creating a nudge to finish before starting something new.

The one limitation developers note: Planning Mode works best for feature-level tasks, not large architectural rewrites. If your task is “migrate the entire monolith to microservices,” the resulting plan.md will be too large and too vague for Cascade to execute reliably. The recommendation from Windsurf’s own documentation is to use smaller, iterative plans — decompose the migration into a series of 10–15 step plans, each scoped to a single service or layer.

Wave 10 and the Cognition Acquisition: What Developers Should Know

Windsurf was acquired by Cognition AI on July 14, 2025, for an undisclosed sum. Cognition was valued at $10.2 billion by September 2025 — two months after the acquisition — making it one of the most valuable AI coding companies in the world. Before the acquisition, Windsurf had reached $82M ARR and was serving 350+ enterprise customers. For developers, the acquisition raises the question of what Cognition AI’s roadmap means for Windsurf’s feature direction. Cognition is the company behind Devin, the autonomous software engineering agent that attracted significant developer attention in 2024 for its ability to complete multi-step coding tasks without human intervention. The Windsurf acquisition gives Cognition a distribution channel — 1M+ active developers — and a production-hardened IDE on which to deploy more autonomous agentic capabilities.

Wave 10’s Planning Mode and Browser integration are the clearest signals of Cognition’s influence on Windsurf’s roadmap. Planning Mode is structurally similar to how Devin manages long-horizon tasks: it creates an external plan that the agent reads and updates across execution steps, rather than relying on in-context memory that degrades as the conversation grows. Browser-aware Cascade echoes Devin’s ability to operate in web-based environments without requiring manual human feedback at each step. If Cognition applies Devin’s full autonomous execution model to Windsurf’s IDE-native context, subsequent waves could include Cascade executing multi-session development plans with minimal human checkpoints — a significant shift from the current model where humans must approve each major action.

For developers choosing between Windsurf and alternatives: the Cognition acquisition signals continued heavy investment and an ambitious agentic roadmap. The risk is lock-in to a platform whose direction is controlled by a company with its own autonomous agent product (Devin) that could eventually compete with or replace the IDE-native model.

Is Windsurf Wave 10 Worth Upgrading For?

Windsurf Wave 10 is worth upgrading for if you regularly work on tasks that span multiple sessions or require iterating on a running frontend. Planning Mode alone justifies a paid subscription for developers who have experienced the pain of re-establishing context at the start of every Cascade conversation on a complex feature. The plan.md workflow is not a gimmick — it directly addresses the most common failure mode of AI-assisted development: context loss between sessions. If your typical task is “fix this one bug” or “write this one function,” Planning Mode adds no value and you should stick with the default Write mode. But if your typical task is “build this feature across four files over two days,” Planning Mode reduces friction meaningfully.

The Windsurf Browser is compelling for frontend and full-stack developers who spend significant time debugging in DevTools or iterating on UI components. The elimination of copy-paste overhead for console logs and DOM context is a real time saver, not a marginal convenience. For backend-only developers who never touch a browser during a coding session, it is irrelevant. The o3 at 1x pricing change is universally positive for any developer using o3 — there is no scenario where paying less for the same capability is a net negative.

The upgrade decision comes down to: do you do multi-session work or frontend debugging? If yes to either, Wave 10 delivers real value at no additional cost over the base paid subscription. Windsurf’s paid plans start at the Pro tier — check the current pricing at windsurf.com for the latest plan structure, as it has changed since the Cognition acquisition.

FAQ

What is Windsurf Planning Mode? Planning Mode is a Cascade conversation mode in Windsurf that generates a persistent plan.md file in ~/.windsurf/plans/ to manage multi-session tasks. Both you and Cascade can edit the file, and Cascade reads it at the start of each session to restore task context without re-briefing.

How do I enable Planning Mode in Windsurf? Open the Cascade chat panel, click the mode selector dropdown (defaults to “Write”), and select “Plan.” Describe your task in the chat, and Cascade will generate the plan.md file automatically. Click “Implement” on the plan file to switch to Code mode and begin execution.

What is the Windsurf Browser? The Windsurf Browser is a built-in Chromium-based browser inside the Windsurf IDE that integrates natively with Cascade. It lets Cascade read your open tabs, console logs, and DOM elements without you copying and pasting content, currently in beta for all self-serve plan users.

Did Windsurf reduce o3 model pricing in Wave 10? Yes. Wave 10 reduced o3 model pricing from 10x credits to 1x credits — a 90% cost reduction. This makes o3 practical as a default model for Planning Mode sessions without burning through monthly credit allocations.

How does Windsurf Wave 10 compare to Cursor? Windsurf Wave 10 has native Planning Mode with a persistent plan file, built-in Chromium browser with tab and console log access, and o3 at 1x credits. Cursor has no native planning mode or built-in browser integration as of early 2026. Cursor maintains an advantage in user familiarity and established VS Code-like workflows.