Agents are built at the fringe: getting from 90 to 100

If an AI can finish your function, what must change before it can continue your work? In 2022, Copilot’s ghost-text suggestions made AI assistance tangible: write some code, see a completion, press Tab. Codeium followed with autocomplete extensions for VS Code, JetBrains, Vim, and Emacs. Kevin Hou, Windsurf’s product engineering lead, reports that those extensions attracted a couple million users.

Autocomplete was a useful starting point, but its interaction model assumed relatively small contributions from the model. Larger models, better training, reinforcement learning, and tool use suggested a different division of labor. Instead of repeatedly accepting completions or copying answers from ChatGPT, developers could delegate longer stretches of work. In this first Windsurf presentation, Hou treats even the IDE as a potentially temporary interface: the enduring objective is to build the best software-development experience as the underlying intelligence improves. By early 2025, that direction had become an agentic editor.

The first demonstration asks Cascade, Windsurf’s sidebar agent, to build a Python web crawler that produces statistics about a website. The work extends beyond generating a source file: Cascade installs dependencies with pip, sets up a virtual environment, and proposes edits with accept and reject controls. Its commands appear in the developer’s interactive terminal, where the developer can inspect and intervene in the work.

A small Python example makes the crawler’s division of responsibilities concrete: fetch a page, parse it, and report a statistic. This illustrates the task rather than reproducing the displayed web_crawler.py:

from html.parser import HTMLParser
from urllib.request import urlopen
import sys


class LinkCounter(HTMLParser):
    def __init__(self):
        super().__init__()
        self.links = 0

    def handle_starttag(self, tag, attrs):
        if tag == "a" and any(key == "href" for key, _ in attrs):
            self.links += 1


def page_stats(url):
    with urlopen(url, timeout=10) as response:
        body = response.read()
        charset = response.headers.get_content_charset() or "utf-8"
    parser = LinkCounter()
    parser.feed(body.decode(charset, errors="replace"))
    return {"bytes": len(body), "links": parser.links}


if __name__ == "__main__":
    print(page_stats(sys.argv[1]))

Writing the function is only part of the agent’s job. The surrounding workflow must also make its environment, execution, and proposed changes visible.

The editor also supports documentation lookup, web search enabled by default, codebase searches with grep, generated commit messages, and image drag-and-drop. The selected crawler frame shows why these capabilities belong together: web_crawler.py appears beside a terminal traceback and Cascade’s repair-and-rerun steps. It captures an intermediate debugging state, not a completed statistics report.

The product objective is to minimize explicit input while producing correct, production-ready code. That means absorbing work developers otherwise do between coding steps: reading stack traces, finding the original source that needs changing, and retrieving documentation for the right package version. Background research and next-step prediction should let developers spend more attention on features and products, with fewer interruptions to assemble context for the agent.

Windsurf launched on November 13, 2024, roughly three months before this presentation. Hou reports 4.5 billion lines of code generated during those first three months. Requests to Cascade included refactors, new features, and new website pages. The figure describes generated volume; the talk does not specify how much was accepted, retained, or regenerated.

That demand also exposed a serving constraint. Hou reports 16 nights of PagerDuty wakeups in roughly 90 days because demand exceeded capacity. He describes the company as one of Anthropic’s and OpenAI’s largest consumers. An agent that contributes more work on the developer’s behalf also creates a larger operational burden for the product serving it.

The first engineering principle is trajectories: use the developer’s ongoing activity to understand what should happen next. Hou contrasts Windsurf’s approach with Cursor in terms of deep editor integration. The agent needs both an observational side—understanding what the developer is doing—and an execution side that can act on that understanding. The resulting interaction can be as short as “Continue my work,” potentially leading to a commit or a full pull request.

Execution still needs selective oversight. Hou describes an LLM judging whether a terminal command can run automatically, with a Git command as a routine example and rm -rf as something likely to trigger confirmation. These are examples of intended behavior, not guarantees about every command. Accept and reject controls provide another intervention point, letting developers review changes before incorporating them into code they will ship.

The mechanism is a unified timeline containing actions from both the developer and the agent. File views, navigation, searches, grep, edits, and commits all contribute context. A human edit should update the agent’s understanding just as an agent edit does. The intended result is to avoid a familiar coordination failure: an assistant acting on an old file state and undoing a change the developer just made. This shared history is an organizing principle of the editor, rather than context supplied only when the user sends a message.

The next demo follows that mechanism through a concrete sequence:

1. The developer adds a function, with autocomplete assisting the edit.
2. The developer asks Cascade to continue the work.
3. Cascade infers that the form handler should use the new function and makes related file changes.
4. Cascade runs npm run dev in the terminal panel opened with Command-J.

The prompt does not spell out the relationship between the function and the handler; the recent edits supply it. Hou describes the interaction as reducing work from minutes to seconds, without presenting a timed comparison.

Terminal activity supplies intent too. If a developer runs npm install or pip install, the agent should recognize the newly installed package and use the surrounding codebase context to infer how to integrate it. The developer should not have to copy the command back into chat. Hou extends this no-copy-paste ambition to documents and websites, while rejecting the idea that the terminal itself must become the whole future interface.

Observation alone is insufficient if execution happens somewhere else. Hou describes agent commands as running inside a sandbox, but places their interaction in the same terminal environment the developer uses, rather than an unrelated background shell script. The important property in the example is environment consistency: whether the human or Cascade installs a Python dependency, it should affect the environment in which the project runs. The presentation does not define the sandbox’s isolation boundaries.

Once the agent can follow an activity trajectory, continuation can become anticipation. Developers remain central to this vision, but the agent looks farther ahead: Hou imagines moving from a few steps of prediction to tens of steps. His future examples are writing unit tests before a function definition is finished and performing a codebase-wide refactor after a variable rename. These are extensions of the shared-timeline idea, beyond the continuation demo just shown.

A trajectory explains the immediate task, but not everything a senior engineer knows about a project. Organizational conventions, architectural decisions, and personal preferences accumulate over time. A capable general-purpose model has not necessarily had that exposure. Windsurf’s second principle, meta-learning, addresses the gap by retaining context about the developer and their organization.

The product combines several distinct mechanisms:

• Memories: A memory bank retains facts such as using Tailwind 4 or React 19 rather than React 18. Hou describes the ambition as telling the agent once and having it remember indefinitely.
• Tool integration: Custom MCP servers connect the agent to preferred tools and workflows.
• Command policies: Allow and deny lists express execution preferences, such as requiring approval before any rm command.

Together, these mechanisms reduce repeated prompting. The longer-term aim is an assistant whose behavior reflects accumulated context, rather than requiring the developer to restate that context for each task.

The memory demo goes beyond an explicit instruction to remember something. A question about what the project does prompts Cascade to inspect files and routes. It then stores an understanding of the architecture and available endpoints for later messages and future conversations. Hou describes this as enabling subsequent work in a single prompt. Documentation lookup follows the same pattern: package versions found in package.json, or supplied by the user, guide searches for matching documentation.

That leads to the distinction between explicit context and inferred context. Windsurf supports rules files, but Hou views manually maintaining them as a temporary burden. Hou predicts that by the end of 2025, 99% of rules-file content will be inferred from the codebase or product usage. This is a forecast about personalization, not a demonstrated result: the envisioned system adapts across companies and developer skill levels without repeatedly asking for the same instructions. The presentation describes the early-2025 product; later documentation linked with the recording concerns legacy Cascade in Devin Desktop and should not be read as the same product snapshot.

The third principle is to scale with intelligence. Once an agent understands the current activity and retains longer-lived context, its architecture should let improved models turn those inputs into better work. That requires planning beyond the current release—to the next several months and years—even while new models and techniques arrive frequently.

The early excitement around ChatGPT’s November 2022 launch quickly encountered limits in what models could reliably accomplish. Teams compensated with embedding indices, retrieval heuristics, and output-validation systems. Hou’s criticism is of designing around a fixed level of intelligence: infrastructure that patches a model’s weaknesses can become a constraint if it prevents the product from benefiting when those weaknesses diminish. This is not a proposal to remove all retrieval or validation; Windsurf’s later examples still rely on retrieval.

One product consequence was replacing legacy chat with Cascade. The user still interacts through a conversational surface, but the system behind it is an agent that can plan and act. Hou suggests users might experience improved answers without noticing that the underlying chat implementation had been replaced.

Context selection provides a more specific example. Explicit @mentions helped users compensate when systems were poor at discovering relevant code and documents. As those capabilities improved, retrieval and agent planning could reconstruct more of the needed context automatically. Hou claims explicit @mentions are unnecessary 90% of the time, without supplying an evaluation method. @file and @web remain useful for directing the agent at the margin; the objective is to stop making that direction a prerequisite for ordinary work.

Consider adding Supabase to a Next.js application. Instead of supplying a chain of @web, @docs, and @codebase references, the developer asks the agent to add Supabase. The agent infers that it needs research, searches the web, and chooses what to read.

Hou contrasts this with hard-coded research rules and a hypothetical embedding index whose results he expects would be worse; he does not present a measured comparison. The mechanism that matters is delegating research decisions to the model, so improvements in its judgment can improve the workflow. He projects the same direction toward more unsupervised work, full pull requests, and complex documentation reading.

The closing vision places Windsurf’s underlying engine at the center: infer conventions rather than requiring rules files, and generate commits and pull requests rather than stopping at isolated edits. Hou presents these as directions for 2025.

Hou reports that Cascade generates 90% of the code its users write, compared with approximately 20–30% for autocomplete. His spoken correction matters: the claim concerns the share of code, not the share of users. The closing slide says “over 90%.” Neither the cohort, observation window, denominator, nor acceptance criteria are supplied, so the figures describe his reported shift in code generation rather than a measured gain in productivity or correctness.

That shift changes the engineering problem. When an agent contributes a larger portion of the work, the developer needs a tool that can participate in the development process, not merely suggest its next fragment. Hou closes by encouraging developers to use agents, then points to an on-screen download QR code and a free tier available at the time of the presentation.