# Building Cursor Composer

Lee Robinson, Cursor

AI Engineer Code 2025

[Talk page](https://ai.engineer/talks/fL1iJHtl51Q-building-cursor-composer) · [Video](https://www.youtube.com/watch?v=fL1iJHtl51Q)

## 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.

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

### How fast can a useful coding agent be?

[0:25](https://www.youtube.com/watch?v=fL1iJHtl51Q&t=25s)

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.](https://ai.engineer/api/talk-essay-media/283f32e8d7f03bba5d6fa083bb2b1014a1ce8429063b03f5fe5160d7ce66989f)

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.**

### Keeping the investigation in the foreground

[2:26](https://www.youtube.com/watch?v=fL1iJHtl51Q&t=146s)

The demonstration uses [Cursor 2.0](https://cursor.com/blog/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.

### Training on complete tool-using attempts

[3:29](https://www.youtube.com/watch?v=fL1iJHtl51Q&t=209s)

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.](https://ai.engineer/api/talk-essay-media/5491d331aba3c56c0267d41ddb369ad4f9330092df1fda185a9b42638b380e37)

Two agent rollouts use different tool sequences and receive different outcomes.

### The simple loop becomes an infrastructure problem

[4:41](https://www.youtube.com/watch?v=fL1iJHtl51Q&t=281s)

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:

| Server | Responsibility | Technology named |
|---|---|---|
| Training | Update model parameters | PyTorch |
| Inference | Generate and coordinate rollouts | Ray |
| Environment | Execute tools in a Cursor-like workspace | Coding 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](https://cursor.com/blog/kernels) 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.

### Keeping rollouts busy in real coding environments

[7:18](https://www.youtube.com/watch?v=fL1iJHtl51Q&t=438s)

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.

### Becoming a practiced user of semantic search

[9:33](https://www.youtube.com/watch?v=fL1iJHtl51Q&t=573s)

Why reproduce the actual environment rather than mock its tools? Semantic search shows what the extra fidelity buys. Cursor trains its own embedding model and indexes a repository so the agent can locate relevant files with natural-language queries. This gives the model a way to look for the meaning of code, rather than relying entirely on exact text matches.

In the [semantic-search study](https://cursor.com/blog/semsearch), Cursor compared agents with and without semantic search on Cursor Context Bench, which tests codebase questions. Robinson reports benefits for nearly every model in Cursor’s harness, with Composer benefiting particularly strongly. The displayed comparison shows a 23.5% relative improvement for Composer with semantic search on that codebase-question evaluation. This measures retrieval-assisted question answering, not a general increase in coding-task success.

![Bar chart lists relative improvement from semantic search: Composer 23.5%, Gemini 2.5 Pro 8.7%, GPT-5 6.5%, Grok Code 11.9%, Sonnet 4 10.0%, and Sonnet 4.5 14.7%.](https://ai.engineer/api/talk-essay-media/1889690a25eb5db48303b41499aad3021de16c631ca503373b2ee04ecd9703af)

Composer shows the largest relative improvement from semantic search in the displayed comparison.

The explanation connects directly to training: Composer practiced with the same search tool it would have at inference time. It could learn when that tool was useful and how to incorporate its results into an investigation. Environment fidelity therefore affects more than whether a call parses correctly; it gives the model experience with the capabilities that distinguish the product.

### Learning to finish sooner and edit more carefully

[10:30](https://www.youtube.com/watch?v=fL1iJHtl51Q&t=630s)

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.

### Getting out of the awkward middle

[12:08](https://www.youtube.com/watch?v=fL1iJHtl51Q&t=728s)

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:

| Mode | Developer relationship | Work pattern |
|---|---|---|
| Fast foreground agent | Stay in the loop | Follow progress and respond directly |
| Powerful background agent | Hand off the work | Let 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.

### The model and its deployment environment develop together

[13:38](https://www.youtube.com/watch?v=fL1iJHtl51Q&t=818s)

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.](https://ai.engineer/api/talk-essay-media/2a29b83f5d1194aa8dfeb281a3abdaa79db40cf27019155f01288838f46226ab)

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.

## Resources

- [Introducing Cursor 2.0 and Composer](https://cursor.com/blog/2-0) — The original announcement of Composer and Cursor 2.0's interface for parallel agents.
- [Composer: Building a fast frontier model with RL](https://cursor.com/blog/composer) — Cursor's technical account of Composer's evaluation, reinforcement learning, tool use, and training infrastructure.
- [1.5x faster MoE training with custom MXFP8 kernels](https://cursor.com/blog/kernels) — A detailed explanation of Cursor's Blackwell kernel optimizations, low-precision training recipe, and layer versus full-training benchmarks.
- [Improving agent with semantic search](https://cursor.com/blog/semsearch) — Offline retrieval evaluations and online experiments measuring semantic search's contribution to coding agents.

## Slides

### Composer intelligence and speed

Composer scores slightly below the best frontier model on Cursor Bench but generates tokens much faster. Robinson says it is about four times more efficient at token generation than models with similar intelligence.

[0:59](https://www.youtube.com/watch?v=fL1iJHtl51Q&t=59s) [Bar charts compare model categories on Cursor Bench intelligence and token generation speed, highlighting Composer.](https://assets.ai.engineer/sites/aiecode2025/sha256/9cfcb9f4460863dc7a3623ad2efaf7ca184fabc2ce50dc2984945d3bd633e46c.webp)

Composer combines coding intelligence with best-in-class speed

Best Open
Fast Frontier
Frontier 7/2025
Composer
Best Frontier

Intelligence (Cursor Bench score)
Axis ticks: 0, 20, 40, 60

Speed (Tokens per Second)
Axis ticks: 0, 100, 200

Composer

AIE / CODE
PRESENTED BY
Google DeepMind

BUILDING A FAST FRONTIER MODEL WITH RL
LEE ROBINSON / VP, Developer Education
CURSOR

### Why Build Composer?

Cursor applied Tab’s low-latency approach to coding agents. Users liked Cheetah’s speed, but said it wasn’t smart enough to be a daily driver for much of their coding.

[1:08](https://www.youtube.com/watch?v=fL1iJHtl51Q&t=68s) [Slide says Composer was inspired by Cursor Tab and that an experimental fast model called Cheetah became popular.](https://assets.ai.engineer/sites/aiecode2025/sha256/3571603802c9f36c5f6ba5f8c35472c024e75976a15cf516cef33570e8ad96f9.webp)

Why Build Composer?

Inspired by Cursor Tab
Our aim was a fast, interactive model that is delightful to use.

Experiments with Cheetah
Prototype fast model in Cursor, quickly became popular.

Composer

Interface text:
AIE / CODE
PRESENTED BY Google DeepMind
BUILDING A FAST FRONTIER MODEL WITH RL
LEE ROBINSON / VP, Developer Education
CURSOR

### Intelligence and Speed

Early users liked the prototype’s speed but found it insufficiently smart for daily coding. Cursor benchmarked correctness and codebase abstractions in its own repos, while targeting fast generation and response times.

[1:51](https://www.youtube.com/watch?v=fL1iJHtl51Q&t=111s) [Slide describing code benchmarking for intelligence and in-editor response speed.](https://assets.ai.engineer/sites/aiecode2025/sha256/c4151252dae06bba90fd342cf1b0bb2bb7226c386751c78219a3a4394bc4fde1.webp)

Intelligence

Realistic Code Benchmarking
Internal benchmark from our own repos. Measures agent’s correctness and its adherence to codebase abstractions.

Speed

In-Editor Speed
Target for fast token LLM generation, but also speed to user response.

Composer

Interface text:
AIE / CODE
PRESENTED BY
Google DeepMind
BUILDING A FAST FRONTIER MODEL WITH RL
LEE ROBINSON / VP, Developer Education
CURSOR

### Cursor Agent Demo

Composer 1 investigates a reported eventbus panic by reading code and searching files. Robinson describes the agent calling tools in parallel as it works through the issue.

[2:33](https://www.youtube.com/watch?v=fL1iJHtl51Q&t=153s) [Cursor agent reviews code and searches files while investigating a reported issue.](https://assets.ai.engineer/sites/aiecode2025/sha256/743a84810e552258f47ff9b9a882732c2a3a95b6ee6acbb7a19c6425115d0ac3.webp)

In
Now · Composer 1

Investigate issue #17638 reports user is seeing panics related to the eventbus in 1.9

Reviewing the eventbus code and issue context.
Read subscribe.go
Searching eventbus pani[illegible]
Searched files **/eventbus/*.go

Interface text:
Agents
Editor
tailscale
Search Agents
+ New Agent
IN PROGRESS
Investigate user panics in event...
Searching files **/eventbus/*.go
ARCHIVED
Add a follow-up
Agent
Composer 1

AIE / CODE
PRESENTED BY
Google DeepMind
BUILDING A FAST FRONTIER MODEL WITH RL
LEE ROBINSON / VP, Developer Education
CURSOR

### Building Cursor Composer

The agenda moves from Agent RL to infrastructure and Composer, with Agent RL highlighted first.

[3:14](https://www.youtube.com/watch?v=fL1iJHtl51Q&t=194s) [Agenda listing Agent RL, infrastructure, and Composer.](https://assets.ai.engineer/sites/aiecode2025/sha256/c40b2ae5af3aa88f939e4143b671b48966b17582f379a072a76aa9ce875023d2.webp)

Building Cursor Composer

Agent RL 1
Infrastructure 2
Composer 3

Composer

Interface text:
AIE / CODE
PRESENTED BY
Google DeepMind
BUILDING A FAST FRONTIER MODEL WITH RL
LEE ROBINSON / VP, Developer Education
CURSOR

### How Cursor Works

A user submits a query to Cursor’s agent, which decides which tools to call. The five shown cover files, codebase search, lints and terminal commands; calls can run serially or in parallel.

[3:26](https://www.youtube.com/watch?v=fL1iJHtl51Q&t=206s) [A user query goes to the Cursor agent, which can read and edit files, search code, collect lints, and run terminal commands.](https://assets.ai.engineer/sites/aiecode2025/sha256/c8912e8e8e5b9564f9ed8ecb67fd3d664b68a2ba0ce59b4c259c9ca63223d246.webp)

How Cursor Works

query
The test should not specify which kind of error the diskspaceErrorFunc should be called with.

tools
Read File
Edit File
Codebase Search
Collect Lints
Terminal Command

Composer

Interface text:
Agent
Composer 1
Local
AIE / CODE
PRESENTED BY
Google DeepMind
BUILDING A FAST FRONTIER MODEL WITH RL
LEE ROBINSON / VP, Developer Education
CURSOR

### Agent RL Challenge: Train / Inference

Composer trains a mixture-of-experts model across thousands of GPUs. The challenge is to keep training fast while matching the training and sampling environments.

[4:44](https://www.youtube.com/watch?v=fL1iJHtl51Q&t=284s) [Slide contrasts training and sampling for a mixture-of-experts language model trained across thousands of GPUs.](https://assets.ai.engineer/sites/aiecode2025/sha256/cf2b703f0045dd6758c6df9bb6e85e4b4694d98928b58017fbff785b4877aff5.webp)

Agent RL Challenge: Train / Inference

Mixture-of-expert language model.
Distributed training on thousands of GPUs.

Training
Sampling

Composer

Interface text:
AI Engineer
Engineering the future of AI

[4:47](https://www.youtube.com/watch?v=fL1iJHtl51Q&t=287s) [Training and sampling icons accompany a description of distributed mixture-of-experts training.](https://assets.ai.engineer/sites/aiecode2025/sha256/ea6e2b479bf785aab60625392debb94142487cf5c4676f5ba3c64e36d6e8e79b.webp)

Agent RL Challenge: Train / Inference

Mixture-of-expert language model.
Distributed training on thousands of GPUs.

Training
Sampling

Composer

Interface text:
AI Engineer
Engineering the future of AI

### Agent RL Challenge: Rollouts

Training uses 100k+ tokens and hundreds of tool calls. The two rollout bars show different lengths; runs can make different numbers of calls and finish at different times.

[5:04](https://www.youtube.com/watch?v=fL1iJHtl51Q&t=304s) [Two colored rollout sequences illustrate long agent runs with many tool calls.](https://assets.ai.engineer/sites/aiecode2025/sha256/e38e368bd25847b58be1d0a38377ca2ab5731a7367f3b95b805d76b32d84c0bf.webp)

Agent RL Challenge: Rollouts

Agent rollouts are complex
We train on 100k+ tokens and 100s of tool calls.

Rollout 1
Rollout 2

Composer
...

Interface text:
AI Engineer
Engineering the future of AI

### Agent RL Challenge: Consistency

Training aims to match Cursor’s production tool formats and responses, but its bursty compute demands create an infrastructure challenge.

[5:26](https://www.youtube.com/watch?v=fL1iJHtl51Q&t=326s) [Composer instances point to tools including file operations, codebase search, lint collection, and terminal commands.](https://assets.ai.engineer/sites/aiecode2025/sha256/a83499e3fcbf5e835bf2b3722951db130c42907d101f3e951604b7e7e62ddf9d.webp)

Agent RL Challenge: Consistency

Training with Cursor
We aim to train in the same environment as Cursor.

tools
Read File
Edit File
Codebase Search
Collect Lints
Terminal Command

Composer
…

Interface text:
AI Engineer
Engineering the future of AI

### Architecture

Composer separates training, inference, and Cursor-simulating environment servers. The inference server sends rollout-based advantages back to the trainer to guide model updates.

[6:32](https://www.youtube.com/watch?v=fL1iJHtl51Q&t=392s) [Trainer, inference, and environment boxes, with an arrow labeled advantages pointing from inference to trainer.](https://assets.ai.engineer/sites/aiecode2025/sha256/0fa7ed8cf115fdd058b2e776f8111efa5593b3ed5618f0169927797d1bb6bd2b.webp)

Architecture

Trainer
Inference
Environment
advantages ←

Composer

Interface text:
AI Engineer
Engineering the future of AI

### Composer Trainer

MXFP8 combines FP8 values with scales. Composer’s custom kernels speed low-precision training and allow faster inference without post-training quantization.

[6:38](https://www.youtube.com/watch?v=fL1iJHtl51Q&t=398s) [An MXFP8 diagram combines FP8 E4M3 values with FP8 E8M0 scales; the slide describes custom kernels for low-precision training.](https://assets.ai.engineer/sites/aiecode2025/sha256/1b1a50d58dbb43e7d6ad26075c3b1004bbf6a64a77609e29194c08f065f0ab7c.webp)

Composer Trainer

Custom kernels for low-precision training
Allows faster inference without requiring post-training quantization.

MXFP8
32
FP8 (E4M3) + FP8 (E8M0)

Composer

Interface text:
AI Engineer
Engineering the future of AI

[6:56](https://www.youtube.com/watch?v=fL1iJHtl51Q&t=416s) [MXFP8 diagram combining FP8 values with shared scales, alongside a note about faster inference.](https://assets.ai.engineer/sites/aiecode2025/sha256/243ce6da40b0a8f3f1bfe18b65384a13e1c20811c116c6fd9ade84480c301d2a.webp)

Composer Trainer

Custom kernels for low-precision training
Allows faster inference without requiring post-training quantization.

MXFP8
32
FP8 (E4M3) + FP8 (E8M0)

Composer

Interface text:
AI Engineer
Engineering the future of AI

### Custom MXFP8 MoE relative speedups

The custom kernels show MXFP8 speedups over BF16: 1.5x end to end on Blackwell, 2x from Hopper to Blackwell, and 3.5x for the MoE layer on Blackwell.

[7:05](https://www.youtube.com/watch?v=fL1iJHtl51Q&t=425s) [Bar chart showing MXFP8 speedups of 1.5×, 2× and 3.5× relative to BF16.](https://assets.ai.engineer/sites/aiecode2025/sha256/df75b5790f0315b40c23f12930491f66855630bc2e6c0cb534eaacb1a8840289.webp)

Custom MXFP8 MoE Relative Speedups

Legend: BF16; MXFP8
Y-axis: Relative Speedup (BF16 = 1.0)
Y-axis ticks: 0.5, 1.0, 1.5, 2.0, 2.5, 3.0, 3.5

E2E (Blackwell): 1.5x
E2E (Hopper→Blackwell): 2x
MoE Layer (Blackwell): 3.5x

https://cursor.com/blog/kernels

AI Engineer
Engineering the future of AI

### Architecture

The trainer sends updated weights to the inference server, which runs rollouts and calls tools. The diagram shows advantages returning to the trainer, with an environment shown as a separate block.

[7:21](https://www.youtube.com/watch?v=fL1iJHtl51Q&t=441s) [Trainer sends weights to inference, which returns advantages; an environment block appears alongside.](https://assets.ai.engineer/sites/aiecode2025/sha256/fcf044e5a8611396e789e0a017e65559d4bff685470443084fcf5077e9111962.webp)

Architecture

Trainer
weights →
advantages ←
Inference
Environment

Composer

Interface text:
AI Engineer
Engineering the future of AI

### Cursor Cloud Agents

Cursor built Cloud Agents alongside its reinforcement learning work. Agents can run from the web or a phone, using cloud virtual machines that load a user's code and let the agent edit files and run tools.

[8:12](https://www.youtube.com/watch?v=fL1iJHtl51Q&t=492s) [Desktop and mobile views of a coding agent interface.](https://assets.ai.engineer/sites/aiecode2025/sha256/6c57490b842258c1d968db96db4122cefa014e712a8b2c3812aba3be40ce7fa5.webp)

AI Engineer
Engineering the future of AI

Interface text:
cursor.com/agents
anysphere/dashboard-ui  copy-stroke-props → main
Fix: Introduce copyStrokeProps function to safely copy stroke-related properties
Squash Merge
View PR
Edit in Cursor
Sonnet 4.5
2 Files  +137 -59
GPT-5
2/6 To-dos
Supernova
3 Files  +42 -11
Add a model secondary popover tooltip to the @ModelSwitcher.tsx
Thought for 8s: What's the safest way to clone stroke-related props without brea...
The previous approach manually copied a few keys (stroke, strokeWidth), but missed others like strokeLinecap. This change introduces a dedicated helper copyStrokeProps to ensure consistent handling.
3 to-dos  3/3
Add a ModelDropdown component under dashboard-ui
Embed it into the tool header
Close popover automatically after selection
Thought for 1s: Add descriptions for each model
icons.ts  src/lib  +4 -3
ModelSwitcher.tsx  src/lib  +11
Plan, @ for contexts, / for commands
Sonnet 4.5

Search Agents
New Agent
Today  4
Edge proxy caching bug
Searching Codebase · agent-cloud
Model selector dropdown polish
2/3 models completed · dashboard-ui
Fix realtime message echo
2 Files  +26 -12 · core-realtime
Update OAuth flow in extensi...  3d
2 models · core-realtime
This week  56
Refactor file upload logic  4d
Improve search index latency  8d
Add analytics events for age...  10d
Adjust theming for dark mode  1D
Show all

Review Sonnet 4.5
3 files
icons.ts  src/lib
1     // Clone stroke-related props manually
2     const stroke = src.stroke || '#000'
3     const strokeWidth = src.strokeWidth || [illegible]
4     return { stroke, strokeWidth }
5 -
6 -   // Safely copy stroke-related props fr[illegible]
7 -   export function copyStrokeProps(source[illegible]
8       const { stroke, strokeWidth, strokeL[illegible]
9       return {
10        [illegible](stroke ? { stroke } : {}),
11        [illegible](strokeWidth ? { strokeWidth }[illegible]
12 +      [illegible](strokeLinecap ? { strokeLinecap[illegible]
13 +      [illegible](strokeLinejoin ? { strokeLinejoin[illegible]
14      }
15    }

ModelSwitcher.tsx  src/components
712     const [open, setOpen] = useState(fals[illegible]
713     const currentModel = models.find((m)[illegible]
714
715 +   // Tooltip for secondary model info
716 +   const tooltip = currentModel?.descript[illegible]
717
718     return (
719       <div className="flex items-center [illegible]
720         <Dropdown open={open} onOpenChang[illegible]
721 +         <Tooltip content={tooltip}>
722 +           <ModelDropdown models={models}[illegible]
723 +         </Tooltip>
724         </Dropdown>
725       </div>

Agent  Dashboard
Plan, @ for contexts, / for commands
Composer 1
mayagao/dashboard-ui  main
Today  4
Edge proxy caching bug
Searching Codebase · agent-cloud
Model selector dropdown polish
2/3 models completed · dashboard-ui
Fix realtime message echo
2 Files  +26 -12 · core-realtime
Update OAuth flow in extension  1d
2 models · core-realtime
Update OAuth flow in extension  2d
2 Files  +11 -3 · dashboard-ui

### Composer Environment

Composer trains on Cursor’s Cloud Agent backend. An internal dashboard visualizes the VM fleet, which needs orchestration to handle spiky training workloads.

[9:02](https://www.youtube.com/watch?v=fL1iJHtl51Q&t=542s) [Slide states that training used the same Cloud Agent backend as Cursor, alongside a cluster dashboard.](https://assets.ai.engineer/sites/aiecode2025/sha256/d3df8d1079c40f38333a84480838415e4e5e3fdf0f623941ce33b154d375de47.webp)

Composer Environment

Production agent server
Training was done on the same Cloud Agent backend as is used in Cursor.

Composer

Interface text:
Select Clusters: [illegible cluster labels]
Group By:
Level 1: Machine Template ID
Add level: Version, State, Tenant ID, Cluster
Machine Template ID: large_firecracker (41 nodes, 2311 pods: 96 active, 2215 hibernated)
[illegible node labels]

AIE / CODE
PRESENTED BY Google DeepMind
BUILDING A FAST FRONTIER MODEL WITH RL
LEE ROBINSON / VP, Developer Education
CURSOR

### Composer learns to be a semantic search power user

Cursor indexes the codebase so agents can search for files in natural language. In Cursor’s agent harness, semantic search improved Composer by 23.5%, the largest relative gain shown.

[9:38](https://www.youtube.com/watch?v=fL1iJHtl51Q&t=578s) [Bar chart compares relative improvement from semantic search across six models, with Composer at 23.5%.](https://assets.ai.engineer/sites/aiecode2025/sha256/da6beba26a4216dbc58f8319afadb89541c3f1ed19cbbfddb0d778aa14d1cbd5.webp)

Composer learns to be a semantic search power user

Model (alphabetical) | Relative improvement from semantic search
Composer | 23.5%
Gemini 2.5 Pro | 8.7%
GPT-5 | 6.5%
Grok Code | 11.9%
Sonnet 4 | 10.0%
Sonnet 4.5 | 14.7%

https://cursor.com/blog/semsearch

AIE / CODE
PRESENTED BY Google DeepMind
BUILDING A FAST FRONTIER MODEL WITH RL
LEE ROBINSON / VP, Developer Education
CURSOR

[9:41](https://www.youtube.com/watch?v=fL1iJHtl51Q&t=581s) [Bar chart comparing relative improvements from semantic search: Composer 23.5%, Gemini 2.5 Pro 8.7%, GPT-5 6.5%, Grok Code 11.9%, Sonnet 4 10.0%, and Sonnet 4.5 14.7%.](https://assets.ai.engineer/sites/aiecode2025/sha256/820431e5001cb8e7092a2a4e4b5bbabae4c762c6ca96307eeffad5bec0812c0d.webp)

Composer learns to be a semantic search power user

Model (alphabetical) | Relative improvement from semantic search
Composer | 23.5%
Gemini 2.5 Pro | 8.7%
GPT-5 | 6.5%
Grok Code | 11.9%
Sonnet 4 | 10.0%
Sonnet 4.5 | 14.7%

https://cursor.com/blog/semsearch

AIE / CODE
PRESENTED BY Google DeepMind
BUILDING A FAST FRONTIER MODEL WITH RL
LEE ROBINSON / VP, Developer Education
CURSOR

### Composer improves with training

Composer’s Cursor Bench score rises with training compute, from near the best open model toward the best frontier model.

[10:34](https://www.youtube.com/watch?v=fL1iJHtl51Q&t=634s) [Scatter plot shows Cursor Bench scores generally rising as training compute increases, from near the best open model toward the best frontier model.](https://assets.ai.engineer/sites/aiecode2025/sha256/d23ec5efe9e64219e97f41c5fbf2af5d371c9b219dc690a1dd42bfd9675fb884.webp)

Composer improves with training

Cursor Bench
Y-axis ticks: 60, 50, 40, 30
Best frontier model
Best open model
Training compute (log)

Composer increases consistently on our benchmark with more training compute

Interface text:
AIE / CODE
PRESENTED BY
Google DeepMind
BUILDING A FAST FRONTIER MODEL WITH RL
LEE ROBINSON / VP, Developer Education
CURSOR

### Model’s learned behavior

The RL model uses a larger share of parallel tool calls and more search and file reads relative to writes. Robinson says it learned to find the right thing before editing.

[11:13](https://www.youtube.com/watch?v=fL1iJHtl51Q&t=673s) [Base and RL comparisons show more parallel tool calls and a greater share of search and file reads relative to writes after training.](https://assets.ai.engineer/sites/aiecode2025/sha256/2e0d58804953aa508081fe1ca7af3e957a87aea2f2edcf0299c939f98eebf15d.webp)

Model’s learned behavior

Composer learns to utilize parallel tool calls for more efficient tool usage.

Composer uses more search and file read tools relative to code updates.

Chart columns: Base, RL
Top chart categories: Serial, Parallel
Bottom chart categories: Write, Search, Read

Interface text:
AIE / CODE
PRESENTED BY
Google DeepMind
BUILDING A FAST FRONTIER MODEL WITH RL
LEE ROBINSON / VP, Developer Education
CURSOR

### Reactions to Composer

One user says Composer is fast enough to work synchronously and quickly iterate on fixes; another illustrates the experience with an orchestra conductor.

[12:09](https://www.youtube.com/watch?v=fL1iJHtl51Q&t=729s) [Social posts praise Composer’s speed and coding experience, alongside an orchestra image.](https://assets.ai.engineer/sites/aiecode2025/sha256/7daea7391dc3339bf7880ffda9c1d2b939fa65766b239f961cc48a7b86d8c0ab.webp)

will brown
@willccbb

ok composer-1 is pretty nuts, and the code it writes is quite nice. probably my new daily driver for many things

not quite as galaxy-brain as codex, but it's SO fast that you can use it sync instead of async, and very quickly iterate on fixes. follows instructions very well

jessald
@jessald

Composer 1 in Cursor is so fast. We are now in the ride the tiger phase of software development.

Anthony
@[illegible]

how it feels using cursor's composer model

Interface text:
AIE / CODE
PRESENTED BY
Google DeepMind
BUILDING A FAST FRONTIER MODEL WITH RL
LEE ROBINSON / VP, Developer Education
CURSOR

### Early Reflections

Cursor found RL effective for specialized coding models and AI tools useful for speeding up research. The team also found that training involved substantial infrastructure work, with scaling still relevant to RL post-training.

[13:37](https://www.youtube.com/watch?v=fL1iJHtl51Q&t=817s) [Reflections on specialized models, AI coding in research, and infrastructure for reinforcement learning.](https://assets.ai.engineer/sites/aiecode2025/sha256/8c5d11e9ba11e42480ae210ea141102c485666d9e48a64cb87f5b9090aa4e064.webp)

Early Reflections

Specialized models work
RL facilitates building targeted models in critical domains.

Building with AI
AI coding is now essential to the research process.

RL is an Infra Challenge
Scaling continues to play a role in RL post-training

AI Engineer
Engineering the future of AI

### AI Engineer Code Summit

[15:24](https://www.youtube.com/watch?v=fL1iJHtl51Q&t=924s) [AI Engineer Code Summit closing card with the event website.](https://assets.ai.engineer/sites/aiecode2025/sha256/1b52ea7f6aa15fcadbdf1dd33141be5e3946235e4adc3f90d8b3af5637d69738.webp)

AI Engineer
Code Summit

https://ai.engineer

## Full transcript

[0:00](https://www.youtube.com/watch?v=fL1iJHtl51Q&t=0s) [on-hold music] Great to be back in New York, and I'm very excited to be here and talk on behalf of all

[0:25](https://www.youtube.com/watch?v=fL1iJHtl51Q&t=25s) of our engineering and research teams at Cursor about building Cursor Composer, our first agent model. And my colleague Sasha actually gave a version of this talk recently, so I'm excited to give my own, uh, my own take on it.

[0:37](https://www.youtube.com/watch?v=fL1iJHtl51Q&t=37s) So Cursor Composer is a model designed for real-world, real-world software engineering, and it tries to be both fast and smart. So as we've measured it against our own benchmarks, it's better than the best open source models.

[0:50](https://www.youtube.com/watch?v=fL1iJHtl51Q&t=50s) It's, like, up against recent frontier models, but kind of slightly below the latest frontier with Sonnet 4.5, GPT-5.1 Codex. But where it really shines is it's about four times more efficient at token generation than models at a similar level of intelligence.

[1:05](https://www.youtube.com/watch?v=fL1iJHtl51Q&t=65s) So we're trying to mesh speed as well as intelligence. So why did we build this model? I mean, obviously Cursor has an IDE. Why are we getting into the model space?

[1:15](https://www.youtube.com/watch?v=fL1iJHtl51Q&t=75s) Why do we care about this? Well, our research and product teams have been building a model called Tab, which you can use for autocomplete. Maybe some of you use that inside of Cursor, and we wanted to take that same approach for a very low latency model and apply it to coding with agents.

[1:29](https://www.youtube.com/watch?v=fL1iJHtl51Q&t=89s) But honestly, we weren't really sure if it would work. So [chuckles] we started prototyping some early versions of what this model could look like, started to put it out and get some feedback from users, and w- we were pretty surprised that this cheetah slug we released for this model, people actually really liked it.

[1:45](https://www.youtube.com/watch?v=fL1iJHtl51Q&t=105s) Uh, they really liked the speed, but the feedback we got was it's not really smart enough yet to be a daily driver for a lot of their coding. So we needed it to be smart and fast.

[1:55](https://www.youtube.com/watch?v=fL1iJHtl51Q&t=115s) Definitely needed to be smart. So we really worked on making this internal benchmark that represented our usage on our own repos and how we actually built software. Like, if we had a model that was both fast and smart and a checkpoint that our developers would use every single day to build the product and to build all of

[2:10](https://www.youtube.com/watch?v=fL1iJHtl51Q&t=130s) our software, then we knew that we would be onto something. And for example, one big change here that helped actually push this towards a level where we had a checkpoint where people would use it was being able to call tools in parallel and being able to very effectively use our semantic search tool, and we'll talk about that

[2:26](https://www.youtube.com/watch?v=fL1iJHtl51Q&t=146s) a little bit more here later. So if you haven't seen it, uh, here's Cursor and, uh, Cursor 2.0 and our new view, and we're going to use the Composer One model.

[2:35](https://www.youtube.com/watch?v=fL1iJHtl51Q&t=155s) And you'll notice that it is doing a lot of things very quickly. It's calling a bunch of tools in parallel, like grep, so reading a lot of files. It's making shell commands.

[2:44](https://www.youtube.com/watch?v=fL1iJHtl51Q&t=164s) Uh, it's making file edits. It's writing and managing, uh, a list of to-dos. And you can kind of very quickly work through tasks in the foreground here. Uh, in this case, I'm investigating an issue in an open source repo.

[2:57](https://www.youtube.com/watch?v=fL1iJHtl51Q&t=177s) And I don't know about y'all, but this has been a quite different programming experience for me, uh, having working with coding agents for a little bit of time now, versus kind of firing off an agent and waiting, let's call it twenty minutes for it to complete where you can kind of context switch away.

[3:11](https://www.youtube.com/watch?v=fL1iJHtl51Q&t=191s) This really does help keep you in the flow and is a kind of a different style of programming, I think. So I wanna talk about how we did this in a way that's hopefully accessible for you all.

[3:20](https://www.youtube.com/watch?v=fL1iJHtl51Q&t=200s) I, I'm not a machine learning researcher, but I do really enjoy this stuff. Uh, what we learned, some of the infrastructure challenges, and then, uh, a little bit on where we're going, uh, moving forward.

[3:29](https://www.youtube.com/watch?v=fL1iJHtl51Q&t=209s) So in Cursor, a user s- kind of submits a query to our back end. The agent reads that query and then decides to make a series of tool calls.

[3:37](https://www.youtube.com/watch?v=fL1iJHtl51Q&t=217s) And our agent has about ten tools, uh, give or take, but we're gonna focus on five here. So reading files, editing files, searching your code base, looking at lints, and then also running terminal or shell commands.

[3:48](https://www.youtube.com/watch?v=fL1iJHtl51Q&t=228s) And the agent then is able to autonomously decide, do we call these serially or do we run these in parallel? And our goal with reinforcement learning here is to try to mirror the Cursor production environment as close as we possibly can.

[4:01](https://www.youtube.com/watch?v=fL1iJHtl51Q&t=241s) So this data that we have in training, we wanna kinda pretend like we're actually calling real Cursor queries. Uh, so to do that, we are running a series of rollouts.

[4:10](https://www.youtube.com/watch?v=fL1iJHtl51Q&t=250s) Um, for example, in this rollout, we're calling a series of tools like reading files and editing files, and when we run more rollouts, we can start from that same initial starting point, but we might call a completely different set of tools.

[4:22](https://www.youtube.com/watch?v=fL1iJHtl51Q&t=262s) So in this one, we're also doing codebase search. So we score the output, we decide which one is better, and then we update the parameters of our model based on that change.

[4:32](https://www.youtube.com/watch?v=fL1iJHtl51Q&t=272s) So conceptually, a pretty simple idea. The challenges come from when you take the simple idea and then you try to scale it up to a very large amount, and so there's kind of three challenges.

[4:41](https://www.youtube.com/watch?v=fL1iJHtl51Q&t=281s) The first one is trying to match the training and inference environment, so when the model's actually being used in the product. Um, in this case, with Composer, we're training a large mixture of experts model, and it's being parallelized across thousands of GPUs, and if we don't speed that up, it's gonna take forever to train the thing.

[4:58](https://www.youtube.com/watch?v=fL1iJHtl51Q&t=298s) So we wanna make it really fast and match the training and kinda sampling version to be as close as possible. The second challenge is that the rollouts can get pretty complex when you start to look at real world data here.

[5:10](https://www.youtube.com/watch?v=fL1iJHtl51Q&t=310s) So models are gonna use hundreds of thousands to millions of tokens. They're gonna make hundreds of different tool calls, and each of these rollouts could take a, you know, a pretty different amount of time.

[5:20](https://www.youtube.com/watch?v=fL1iJHtl51Q&t=320s) One might make a lot of tool calls, one might make not as many, and they'll complete at different times, so we have to figure out how to deal with that challenge.

[5:27](https://www.youtube.com/watch?v=fL1iJHtl51Q&t=327s) And finally, there's this challenge of consistency. If we want to mimic the production Cursor environment as close as possible, we need to use exactly the same tool format and the tool response.

[5:37](https://www.youtube.com/watch?v=fL1iJHtl51Q&t=337s) But in training, we have this really bursty amount of compute, basically. We're, like, doing all of this training all at once, which is different than at production. So it is really an infrastructure challenge.

[5:49](https://www.youtube.com/watch?v=fL1iJHtl51Q&t=349s) We have these three machine learning challenges, and all of the solutions, coincidentally, are actually infrastructure problems. So let's talk through a few of these problems and how we solved it at the infrastructure layer.

[6:00](https://www.youtube.com/watch?v=fL1iJHtl51Q&t=360s) So our architecture is probably familiar for some of you who have been involved in this space a little bit, but I still think it's really interesting to talk about at kind of a high level.

[6:09](https://www.youtube.com/watch?v=fL1iJHtl51Q&t=369s) Uh, we have three different servers. We have a training server. We have kind of the standard ML stack with PyTorch. We have an inference server, so the rollouts that I just talked about, um, that's where we use Ray, and then we have environment servers, and these are the ones where we're kind of simulating that Cursor environment that

[6:24](https://www.youtube.com/watch?v=fL1iJHtl51Q&t=384s) I talked about. And all these servers talk to each other. So for example, the inference server can basically send these advantages back to the trainer, which is like nudging it up or down, uh, b- based on the rollout, and then updating the model and getting new parameters.

[6:40](https://www.youtube.com/watch?v=fL1iJHtl51Q&t=400s) So this, this one is a bit more on the ML side, but we're, we're trying to train a model that's very, very large and to do it as fast as possible.

[6:47](https://www.youtube.com/watch?v=fL1iJHtl51Q&t=407s) And one way that our team was able to do this on the research side was to develop a library of custom kernels that allowed for very low-precision training. And basically, this just allows us to just speed up the training process in a big way and also make it much easier to ship to our inference server.

[7:03](https://www.youtube.com/watch?v=fL1iJHtl51Q&t=423s) So if you're the type of person who loves this, we wrote a blog post going way in-depth on all of this. It talks about our custom kernels. Uh, if you're interested, the TLDR here is we found for the mixture of experts layer was about three and a half times faster, uh, a speed-up on NVIDIA Blackwell chips.

[7:18](https://www.youtube.com/watch?v=fL1iJHtl51Q&t=438s) So it made a pretty significant, uh, impact on our training runs. So once we update the weights, we need to send them back over to the inference server, uh, during this training process, and the inference server is the one that's doing all the rollouts that I talked about, calling the tools and kinda managing, um, what we sent.

[7:35](https://www.youtube.com/watch?v=fL1iJHtl51Q&t=455s) The challenge here, uh, [chuckles] is that they all complete at different times. So kind of a naive version of this, there will be a lot of wasted time. So what we were able to do is do load balancing across the different threads and processes to basically shift the work around and, and not have a bunch of idle time.

[7:52](https://www.youtube.com/watch?v=fL1iJHtl51Q&t=472s) So if one rollout, for example, makes a ton of tool calls, maybe it installs some packages, installs some library, we're not just sitting there waiting for all of the other ones to finish.

[8:01](https://www.youtube.com/watch?v=fL1iJHtl51Q&t=481s) The inference server is spending all this time going back and forth, making the tool calls to the environment, uh, and getting the tool results back, so again, communicating between these servers, and we want that environment to be as close as possible to the Cursor product.

[8:15](https://www.youtube.com/watch?v=fL1iJHtl51Q&t=495s) One thing that's nice about having both the coding agent, the IDE, as well as what we're doing with the model research and training our own models, is we can kind of co-design these things together.

[8:24](https://www.youtube.com/watch?v=fL1iJHtl51Q&t=504s) So as we were building out a lot of our RL work for this model, we were also building our Cloud Agents product. Um, this is how you can run a Cursor agent kind of offline.

[8:34](https://www.youtube.com/watch?v=fL1iJHtl51Q&t=514s) You can run it from your phone or on the web or kick it off from Slack, for example. And to do this, we spin up virtual machines in the cloud.

[8:41](https://www.youtube.com/watch?v=fL1iJHtl51Q&t=521s) So each one of these VMs loads up the user's code. Uh, it allows the agent to kinda like make file changes, run tools, and edit code in a secure sandbox.

[8:50](https://www.youtube.com/watch?v=fL1iJHtl51Q&t=530s) And coincidentally, this is the perfect infra for RL and our use in training. So we have this like fleet of cloud VMs, and we have an environment that very closely matches the production Cursor environment, and we can then use that for training.

[9:05](https://www.youtube.com/watch?v=fL1iJHtl51Q&t=545s) This does still have some challenges, though. I kinda talked about how the training workload is very spiky, and it's different than the kind of standard inference when you're running the Cloud Agents product.

[9:14](https://www.youtube.com/watch?v=fL1iJHtl51Q&t=554s) So we needed to build infrastructure to support all of these VMs and orchestrating between them. So, you know, we have many different clusters, hundreds of thousands of VMs here, and you can see behind me one of the internal dashboards we built, uh, with Composer actually, to visualize, uh, all of the different VMs in the fleet.

[9:33](https://www.youtube.com/watch?v=fL1iJHtl51Q&t=573s) So why spend all this time trying to match the environment to be as close as possible to Cursor production? I've kinda mentioned that a few times. We could mock it.

[9:43](https://www.youtube.com/watch?v=fL1iJHtl51Q&t=583s) We could simulate it out. Um, but one of the really nice benefits is we get to give the model, uh, specific tools that we think are very valuable inside of the agent.

[9:51](https://www.youtube.com/watch?v=fL1iJHtl51Q&t=591s) So one of those is that we've trained our own embedding model that allows you to do semantic search. So when you use Cursor, we go and index your code base, and then it allows the agent to make natural langua- natural language queries to find files that it might wanna edit.

[10:07](https://www.youtube.com/watch?v=fL1iJHtl51Q&t=607s) And we did some research on this recently. We found that semantic search not only helped basically every single model inside of the Cursor agent harness, but it was particularly helpful with Composer, which kinda makes sense when you think about it.

[10:19](https://www.youtube.com/watch?v=fL1iJHtl51Q&t=619s) Like, we trained Composer in the exact same environment that we're using at inference time, and so the model kind of becomes a power user of this tool, which is really effective.

[10:30](https://www.youtube.com/watch?v=fL1iJHtl51Q&t=630s) So let's talk about, uh, how the release has been going and kind of where we're going next. Um, as we were doing the training process, we kind of knew that RL was working when we were able to continuously improve the model and start to see more and more improvements after more and more rollouts.

[10:47](https://www.youtube.com/watch?v=fL1iJHtl51Q&t=647s) So we started about kinda the same performance as the best open model, and then as we trained and kind of threw more compute at it, the performance continued to increase, and to a point today where we're close to the frontier in terms of kind of the best coding agents that are available.

[11:02](https://www.youtube.com/watch?v=fL1iJHtl51Q&t=662s) And personally, I think this is a great sign just for being able to take and scale RL and apply it to these very hard specialized tasks, like in our example, coding, but it could be applied to other domains as well.

[11:14](https://www.youtube.com/watch?v=fL1iJHtl51Q&t=674s) Uh, RL also allowed us to kind of change properties of the model in a way that was very useful for the Cursor product. We wanted the model to be both kind of fast at generating tokens, but also the end-to-end experience of getting a result that's helpful.

[11:29](https://www.youtube.com/watch?v=fL1iJHtl51Q&t=689s) So for example, instead of reading a file one by one, you can read 10 files in parallel with tool calling. And as you saw in the demo earlier, it makes Composer feel much faster when you have that.

[11:39](https://www.youtube.com/watch?v=fL1iJHtl51Q&t=699s) And we think this is kind of just the start. There's a lot more we can do in this area to speed up the model. Uh, and the second one is the model learned how to behave better as an agent.

[11:48](https://www.youtube.com/watch?v=fL1iJHtl51Q&t=708s) So in the beginning, the model was, was kinda making too many edits. Sometimes the edits were made unnecessarily. But as we trained more and more, the model actually got surprisingly better at learning to search and read files more.

[12:01](https://www.youtube.com/watch?v=fL1iJHtl51Q&t=721s) So it would go and find the right thing before it tried to make edits, overall just being, uh, uh, you know, a bit more effective.

[12:08](https://www.youtube.com/watch?v=fL1iJHtl51Q&t=728s) So we released Composer last month in Compers-- uh, Cursor 2.0, and so far, it seems like people seem to like it. Has anyone here tried the model by chance?

[12:17](https://www.youtube.com/watch?v=fL1iJHtl51Q&t=737s) Okay, that's pretty great. That's more than I expected, so that's great to hear. I think from my perspective, using this model and, and using coding agents for some time, I kinda describe this problem as, like, airplane Wi-Fi.

[12:28](https://www.youtube.com/watch?v=fL1iJHtl51Q&t=748s) So when you're on airplane Wi-Fi, uh, it works, but it's kind of frustrating. You really want to do whatever you're trying to do, but it's just, it's a little slow, almost to where sometimes you wish that you just didn't have Wi-Fi at all. [laughs]

[12:39](https://www.youtube.com/watch?v=fL1iJHtl51Q&t=759s) And I think for some of us who adopted coding agents very early, it kinda feels like airplane Wi-Fi sometimes, 'cause if it's taking ten or twenty minutes, you're in this weird, I think [REDACTED:origin] called it semi-async valley of death, where you either want something that's really fast, or you want the most powerful, most intelligent model that can

[12:57](https://www.youtube.com/watch?v=fL1iJHtl51Q&t=777s) run for, you know, a significantly long amount of time, maybe in the background, maybe, you know, thirty minutes, hours, days. And I think when you're stuck in the middle, that's, that's very, very painful.

[13:06](https://www.youtube.com/watch?v=fL1iJHtl51Q&t=786s) So for me, Composer, and I think other people, it's brought a lot of joy back to coding with agents that felt more like when you were writing code by hand, where you're very in the loop, very synchronous.

[13:17](https://www.youtube.com/watch?v=fL1iJHtl51Q&t=797s) So I'm excited to see more people exploring this space as well. For me daily, uh, I'm writing a lot of plans with kind of the latest, uh, model, like the, the highest frontier, so GPT-5.1 Codex is, is really great for plans.

[13:29](https://www.youtube.com/watch?v=fL1iJHtl51Q&t=809s) Uh, and then I'm using Composer to actually take that plan, kinda like what Dex talked about, like, take the context engineering work, and then actually go and build the thing with it.

[13:38](https://www.youtube.com/watch?v=fL1iJHtl51Q&t=818s) So, uh, a few reflections from our research and products team on building Composer. The first is that RL can work surprisingly well for training very specific models and, you know, giving it this high-quality data and a decent amount of compute.

[13:55](https://www.youtube.com/watch?v=fL1iJHtl51Q&t=835s) You know, at, at Cursor, we're not trying to build general intelligence. We're not trying to build AGI. We're trying to build very good coding models, and our hu- RL has worked surprisingly well for that.

[14:06](https://www.youtube.com/watch?v=fL1iJHtl51Q&t=846s) The second one is, uh, how much tools, AI tools like Cursor, it doesn't have to be Cursor, but like Cursor, really help speed up research and development. You know, of course, our entire team uses Cursor to help them write code and debug code more efficiently, but that speed up, that increase really compounds across all of our engineering

[14:25](https://www.youtube.com/watch?v=fL1iJHtl51Q&t=865s) efforts, so we're able to try more ideas, ship product faster, try new research, um, so it's been really, really helpful there. And the last one that's, you know, personally pretty interesting for me is that [laughs] it was interesting to see how much of the ML work in the training process was actually also an infrastructure problem.

[14:43](https://www.youtube.com/watch?v=fL1iJHtl51Q&t=883s) They were very correlated. And going back to my time at Vercel, we saw a very similar thing where a lot of the magic moments that you can have in working in frameworks in the JavaScript or Python space, you also need to think a little bit about the infrastructure of where they're actually deployed.

[14:57](https://www.youtube.com/watch?v=fL1iJHtl51Q&t=897s) So these things are, are more related than people might think. So those are some of our reflections. Uh, sounds like some of you have tried it out. If this is something that you're interested in and working on, we're hiring pretty much across the board at Cursor right now.

[15:08](https://www.youtube.com/watch?v=fL1iJHtl51Q&t=908s) We just opened up an office in New York, if you're here based in New York, and we'd love to talk to you about building the best coding models in the world.

[15:15](https://www.youtube.com/watch?v=fL1iJHtl51Q&t=915s) Thank you. [audience applauding] [upbeat music]
