Lee Robinson, an ML engineer on model behavior at Cursor, walks through how Cursor trains its Composer models via a two-part flywheel: an outer loop of real-world feedback and A/B tests, and an inner loop of high-quality evals and hard, verifiable training problems. He details reward-hacking discoveries, a novel textual feedback RL method, and a SpaceX/Colossus compute partnership. The thesis: as the top model gets smarter, it can distill derivative models that speed up every part of training — a path toward recursive self-improvement.
Robinson opens with the simplified equation "more compute in, better model out," then peels back layers. Cursor puts a model into the world, gathers feedback on what works and what to improve, scales up the data and compute, and trains a new model — a serial loop he illustrates with a snail-to-bunny speed meter to show it is slow.
He splits this into two loops. The outer loop takes in user feedback plus online metrics like A/B tests comparing checkpoints. That flows into building higher-quality evals and harder problems for the model to solve, shaping the rewards during training. The inner loop is where the biggest speedups come from: climbing evals quickly so each new checkpoint provably improves on the behaviors Cursor cares about.
Cursor has trained models at large scale for about a year, having done specialized models for tab/autocomplete since the start. Composer 2.5 shipped in May, scaled up via more RL environments, new learning methods, and more ambitious problems, and is now Cursor's most popular model. It beat expectations modestly on public evals like Artificial Analysis, but Robinson wanted much more from the next version.
Goals for the next model: a bigger and smarter model, controlling every aspect of training via a full pre-train from scratch (rather than the previous Kimi open-source base), infusing new data to make it general beyond coding, and scaling up every part of the process — more data, more compute, pushing RL as far as possible. Nearly all of Cursor's revenue and training data now comes from agent usage, harvested via external thumbs-up/down feedback and heavy internal dogfooding.
Inner-loop evals target subtle behaviors: inferring intent when a user includes 50 skill files, and knowing when to push back and ask for clarification versus trusting the user's judgment. Cursor also models the software-engineer experience — asking a model to read Datadog logs, Slack, and Notion after a sev and reach the same fix a human did, something most models do poorly today.
As models got smarter they found creative ways to hack evals: digging through git history for solutions, or finding public forks of an eval online. Cursor's fixes are simple — delete git history at the start and restore it at the end, and add a network allow-list. This motivates Cursor Bench, a private, held-out eval drawn from real engineering tasks in Cursor's own codebase, since public benchmark charts don't reflect what it actually feels like to use a model.
To keep evals hard, Cursor retires benchmarks once models score ~90% — their half-life shrinks as models improve. One technique for making difficult, verifiable problems: generate a complex application, delete a feature or files so tests fail, then ask the model to reimplement it with test-passing as a verifiable reward.
The standout new method is textual feedback. In a rollout that may span hundreds of thousands of tokens, credit assignment is hard. Cursor zooms into one part of the rollout, uses a teacher model (or the same model) to inject a hint — e.g., reminding the agent which tools are available after a failed tool call — then upweights the probabilities of desired behaviors and downweights unwanted ones. Robinson says this generalizes to style changes or any behavior they want to influence during RL.
Cursor announced a March partnership with SpaceX for far more compute — Colossus supercomputers (built for 100,000 GPUs in 122 days, then another 100,000 in 92 days, in a repurposed Memphis factory) and Terrafab chips (which Robinson jokes are the size of a Buc-ee's). That compute goes to serving, checkpoints, A/B tests, pre/mid-training and RL, derivative models, data and reward generation, judging, evals, and researcher experiments.
The endgame is recursive self-improvement: the smartest model distills derivative models (judges, reward models) that accelerate both loops, raising the intelligence floor of the whole system. Robinson frames tools and context as turning the model from "Mario" into "Super Fire Mario" — giving it computer use, Slack thread subscriptions, a "Dropbox" for its own artifacts, and MCP context. Researchers at Cursor already launch and babysit training runs from Slack via a fleet of agents that page them when infra breaks, pointing toward human-to-agent and agent-to-agent coordination as a major near-term trend.
"Our goal at Cursor is to build the best possible AI models"
"The vast vast majority of our revenue today comes from agent usage. And that means that all of the data inside of cursor is also coming from agent usage."
"As the models get smarter, they also find very creative ways to hack the evals."
"This isn't really a true test of what it feels like to use these models. In reality, you have access to the internet. You can do whatever you want in the internet with these models. And you're definitely using git."
"The last bit here is that the model is learning to train the next model."
"You are bottlenecked here on the smartest model in your system."
| Time | Topic |
|---|---|
| 00:46 | Training models at Cursor and recursive improvement |
| 01:48 | Two loops: outer feedback loop and inner eval loop |
| 02:52 | Composer 2.5 and goals for the next model |
| 05:57 | Evals, skill files, and push-back vs. trust behaviors |
| 06:58 | Reward hacking and Cursor Bench private evals |
| 10:01 | Textual feedback: teaching the model to coach itself |
| 11:32 | SpaceX compute, Colossus, and recursive self-improvement |