AI Engineer Code 2025

Building Cursor Composer

Loading slides…

Read the talk

Building Cursor Composer: Fast Agents Need Real Environments

Composer combines low-latency generation with learned tool use, backed by reinforcement learning infrastructure that closely matches the environment where developers actually work.

From a talk by Lee Robinson

Before you start: Basic familiarity with coding agents and tool calls is helpful; no reinforcement learning background is required.

How fast can a useful coding agent be?

Can a coding agent be fast enough to work alongside a developer while still being smart enough for real software engineering? Composer, Cursor’s first agent model, targets that combination. Lee Robinson introduces the work of Cursor’s engineering and research teams, building on an earlier presentation by his colleague Sasha. On Cursor’s internal benchmarks, Robinson places Composer above the best open models and slightly below the then-current frontier represented by Sonnet 4.5 and GPT-5.1 Codex.

Robinson reports roughly four times the token-generation speed of models at a similar intelligence level. That is a generation-speed comparison, not a claim that every coding task finishes four times faster. Cursor’s published benchmark methodology uses its internal harness and tokenizer-normalized tokens per second; the model comparisons here describe the release-era landscape.

Two horizontal bar charts compare intelligence measured by Cursor Bench score and speed in tokens per second, with Composer highlighted in black.Open full source frame
Composer compared with other model categories on intelligence and speed.

The precedent was Tab, Cursor’s autocomplete model: low latency already mattered when suggesting the next edit, and the team wanted to bring that responsiveness to agents. Early prototypes released under the cheetah name earned encouraging feedback about speed. But users did not find them capable enough to serve as their daily coding model.

Cursor therefore built an internal benchmark around its own repositories and development work. The practical acceptance criterion was a checkpoint that Cursor’s developers would choose every day to build the product. Two changes helped reach it: calling tools in parallel and using semantic search effectively. Fast generation needed to be paired with competent decisions about what to do next.

0:250:37
Suggest correction

This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.

0:25 · section reference included

Keeping the investigation in the foreground

The demonstration uses Cursor 2.0, its new agent view, and the model labeled Composer One. While investigating an issue in an open-source repository, the agent makes parallel grep calls, reads files, runs shell commands, edits files, and maintains a to-do list. The distinctive feature is the succession of visible actions: the investigation keeps moving while the developer watches.

That creates a different interaction from launching an agent and returning much later. Robinson uses a roughly twenty-minute wait as an example of a task long enough to encourage context switching. A responsive agent instead lets the developer stay with the problem and follow its progress. From there, he turns to the training and infrastructure that make this style of programming possible, explaining them from his perspective as an engineer rather than an ML researcher.

2:262:35
Suggest correction

This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.

2:26 · section reference included

Training on complete tool-using attempts

A user query arrives at Cursor’s backend, and the agent decides which tools to call. Robinson describes roughly ten available tools, highlighting five categories: reading files, editing files, searching the codebase, inspecting lints, and running terminal commands. The agent also chooses whether calls should happen serially or in parallel. The reinforcement learning environment aims to reproduce those production choices as closely as possible.

The unit of experience is a rollout: one attempt to respond to a query through a sequence of actions. Training can explore different attempts from the same initial state:

  1. Start with the same query and environment.
  2. Let the model choose and execute a sequence of tools.
  3. Repeat from that starting point, allowing a different sequence.
  4. Score the outputs and compare the attempts.
  5. Update model parameters using the resulting feedback.

In the illustrated pair, one attempt reads and edits a file; another includes codebase search before reading and editing. The completed slide marks the first with an X and the second with a check. It makes the training signal concrete: alternative paths through the tools can produce different outcomes.

Agent RL slide shows Rollout 1 using Read File and Edit File with an X, and Rollout 2 using Codebase Search, Read File and Edit File with a check mark.Open full source frame
Two agent rollouts use different tool sequences and receive different outcomes.
3:293:37
Suggest correction

This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.

3:29 · section reference included

The simple loop becomes an infrastructure problem

Scaling this loop introduces three constraints:

  • Training and sampling alignment. Composer is a large mixture-of-experts model distributed across thousands of GPUs. Training must be fast, while remaining closely matched to the model used to generate rollouts.
  • Uneven rollout duration. Robinson describes attempts consuming hundreds of thousands to millions of tokens and hundreds of tool calls. Different paths take different amounts of time, so completion is irregular.
  • Production tool fidelity. Training needs the same tool formats and responses as the product, but its demand arrives in large bursts rather than the pattern of ordinary production traffic.

These begin as requirements for learning useful behavior, but satisfying them depends on the systems around the model.

The architecture separates three server roles:

ServerResponsibilityTechnology named
TrainingUpdate model parametersPyTorch
InferenceGenerate and coordinate rolloutsRay
EnvironmentExecute tools in a Cursor-like workspaceCoding environments

The inference side sends rollout advantages back to the trainer: signals that nudge learning toward or away from the behavior in an attempt. The trainer uses that feedback to produce updated parameters. Keeping environment execution separate lets the system reproduce the coding workspace without making it part of the training server itself.

To accelerate the large model, Cursor developed custom kernels for very low-precision training. Robinson describes two benefits: faster training and an easier handoff to inference. He reports approximately 3.5× speedup for the mixture-of-experts layer on NVIDIA Blackwell chips. The corresponding kernel report distinguishes that layer result from approximately 1.5× end-to-end training throughput on Blackwell against BF16; the layer improvement should not be applied to the entire training run.

4:414:58
Suggest correction

This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.

4:41 · section reference included

Keeping rollouts busy in real coding environments

After a training update, the new weights return to the inference server for further rollouts. Those rollouts do not finish together. One may perform a long sequence of tool calls or install a package while another completes quickly. A naive schedule leaves capacity idle around those differences. Cursor load-balances work across threads and processes so that uneven attempts do not create as much wasted time. Throughout a rollout, inference sends tool requests to environment servers and receives their results.

Owning both the coding product and the model work offered a useful opportunity: Cursor was building Cloud Agents alongside Composer’s reinforcement learning system. A Cloud Agent can run away from the local IDE, launched from a phone, the web, or Slack. Its cloud VM loads the user’s code and provides a secure sandbox for file changes and tool execution.

That same infrastructure supplies realistic RL environments. Instead of creating an unrelated approximation of a coding workspace, the training system can use the infrastructure built to run agents for users. The remaining difficulty is operational: training demand is much spikier than Cloud Agents traffic. Robinson describes orchestration across many clusters and a fleet of hundreds of thousands of VMs, showing an internal fleet dashboard that the team built with Composer.

7:187:35
Suggest correction

This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.

7:18 · section reference included

Learning to finish sooner and edit more carefully

As training continued, Cursor saw further improvements from additional rollouts and compute. Robinson describes a progression from roughly the performance of the best open model toward frontier coding agents. He sees this as encouragement for applying reinforcement learning to difficult, specialized tasks, with coding as the demonstrated domain and other domains as a possible extension.

End-to-end responsiveness depends on the action sequence as well as token speed. Robinson’s example is reading ten files in parallel instead of reading them one by one. Once the paths are known and the reads are independent, the same scheduling principle can be expressed in Python:

python

from concurrent.futures import ThreadPoolExecutor
from pathlib import Path


def read_files(paths: list[Path]) -> dict[Path, str]:
    def read(path: Path) -> str:
        return path.read_text(encoding="utf-8")

    with ThreadPoolExecutor(max_workers=10) as pool:
        contents = list(pool.map(read, paths))

    return dict(zip(paths, contents))

Here the result still associates each path with its contents, while independent reads can overlap. The agent-level decision is when such a batch is appropriate: a search that discovers the paths must still happen before reading them. Composer’s training made parallel tool use part of its behavior, improving the experience seen in the earlier demonstration.

Robinson also describes a change in restraint. Early checkpoints made too many edits, including unnecessary ones. With more training, Composer increasingly searched and read files before changing them, finding the relevant code before attempting a fix. Further speed work remained ahead, but the behavioral improvement already went beyond doing the same actions faster: the model was learning a more effective order of operations.

10:3010:47
Suggest correction

This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.

10:30 · section reference included

Getting out of the awkward middle

Composer launched with Cursor 2.0 on October 29, 2025—the month before this conference. When Robinson asks who has tried it, the audience response is larger than he expected. His description of the experience starts with airplane Wi-Fi: it works, but it is slow enough to make the activity frustrating.

Coding agents can occupy a similarly awkward middle, which he calls the “semi-async valley of death.” A ten- or twenty-minute task is too slow for continuous interaction, yet may still demand enough attention to prevent the developer from fully leaving it behind. The useful alternatives sit on either side:

ModeDeveloper relationshipWork pattern
Fast foreground agentStay in the loopFollow progress and respond directly
Powerful background agentHand off the workLet it run for an extended period

Robinson contrasts the frustrating middle with background work that might run for thirty minutes, hours, or days. Those durations describe interaction patterns, not measured Composer completion times. For him, Composer restores some of the enjoyment of writing code by hand because the work feels synchronous again.

His own workflow combines the two strengths at the model level. He uses GPT-5.1 Codex to develop plans, then asks Composer to implement them. The plan supplies prepared context for the faster implementation model—a practical application of the context-engineering work discussed earlier at the event by Dex.

12:0812:17
Suggest correction

This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.

12:08 · section reference included

The model and its deployment environment develop together

The first research lesson is about specialization. With high-quality data and substantial compute, reinforcement learning worked well for Cursor’s specific objective: building good coding models. Robinson explicitly separates that objective from pursuing general intelligence. A production-shaped task, environment, and toolset give the training effort a concrete target.

The second lesson concerns the process of building the system. Robinson reports that Cursor’s team uses AI assistance throughout coding and debugging. Improvements there compound across engineering work: the team can try more ideas, ship product changes, and run additional research. The fleet dashboard built with Composer is one concrete instance of the product helping construct its own supporting infrastructure.

The final lesson returns to the relationship between ML and systems engineering. Many of the obstacles to training Composer became infrastructure problems: supplying realistic execution environments, coordinating uneven work, and moving efficiently between training and inference. Robinson connects this to his experience at Vercel, where the experience of using a JavaScript or Python framework depends partly on the infrastructure that runs it. The useful behavior of an agent is shaped by both the model and the environment in which it operates.

Early Reflections slide lists three lessons: specialized models work, AI coding is essential to research, and scaling continues to matter in RL post-training.Open full source frame
Early reflections: specialized models, building with AI, and RL infrastructure.

He closes with an invitation to help build those coding models: Cursor was hiring across roles and had opened a New York office.

13:3813:55
Suggest correction

This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.

13:38 · section reference included

Resources

From the talk

Transcript download
Full transcript

Loading transcript…