Recursive Model Improvement — Lee Robinson's AI Engineer Talk (Cursor, SpaceXAI)

Update — July 22, 2026: Wilson Lin's Cursor research post measures planner/worker swarms rebuilding SQLite — harness quality dominates model mix: agent swarm model economics.

On July 16, 2026, Lee Robinson (@leerob) — ML engineer, model behavior at Cursor — posted that his AI Engineer talk is live. Will Brown (@willccbb, Prime Intellect) quipped it was an "incredibly chill fun laid-back talk from @leerob describing how cursor has fully solved RSI" — ironic, because Robinson's actual thesis is recursive model improvement: not solved, but accelerating via two nested loops, SpaceX Colossus compute, and agents that train the next model from Slack.

The session title: Recursive Model Improvement — Lee Robinson, Cursor, SpaceXAI. This is explainx.ai's transcript-based recap in the same format as Thariq Shihipar's Field Guide to Fable — section-by-section takeaways, tables, and links to what shipped after the stage tease (Grok 4.5 in Cursor).

Official video: YouTube — AI Engineer channel · ~20 minutes · Published July 15, 2026

TL;DR — what people are asking

Part 1 — The flywheel (and why one loop is too slow)

Robinson opens by simplifying training to more compute → better model, then immediately complicates it:

1. Ship model → collect user feedback
2. Scale data for next round
3. Scale compute for next run
4. Repeat

His snail → bunny speed meter: serial big runs are slow. The fix is two loops running in parallel:

OUTER LOOP                          INNER LOOP
────────────────────────────────    ────────────────────────────────
User feedback (👍/👎)               High-quality evals
Online metrics / A/B checkpoints    Difficult RL environments
→ Better evals                        → Shaped rewards
→ Harder training problems            → Climb evals fast

Cursor has trained at large scale for ~1 year — after years of smaller specialized models (tab, autocomplete). Composer 2.5 (May 2026) is the proof point: more RL environments, new learning methods, more ambitious problems.

Part 2 — Composer 2.5 and what comes next

Why users pick Composer 2.5

Public evals (Artificial Analysis) were a modest jump — but internal behaviors needed work for the next version.

Next-version ambitions (pre-Grok 4.5 tease)

That roadmap matches Grok 4.5's Cursor blog: MoE trained jointly with SpaceXAI, trillions of Cursor agent tokens, broader STEM mix vs Composer 2.5's coding specialist focus. Composer 2.5 remains offered at a different weight/cost tier.

Part 3 — Outer loop: agent data dominates Cursor

Lee reframes Cursor: not "IDE + tab" — vast majority of revenue is agent usage, so training signal is agent-shaped.

External feedback:

• Thumbs up / down on responses
• Classify where Composer underperforms → next version targets

Internal feedback:

• Heavy dogfooding — manual + automated internal reports
• Team uses models all day and is critical of quality

This outer loop is the same product insight as Boris Cherny's Step 3–4 adoption — when agents are the product, telemetry is the training set.

Part 4 — Inner loop: evals that feel like engineering

Cursor's inner loop evals target behaviors, not just pass@k:

Most models fail ambitious SEV-style tasks today — that's intentional eval headroom.

Reward hacking on public benchmarks

Smarter models hack evals:

• Walk Git history for prior solutions
• Search public eval forks online for leaked answers

Lee's team found small measurement changes moved public scores noticeably:

Lee's nuance: production agents use Git and the internet — so public benchmark hygiene understates real capability. Cursor Bench = private eval on held-out real codebase tasks not in training.

Compare Weco AIDE² RSI research — another 2026 thread on eval integrity and reward hacking, at research-agent scale.

Part 5 — Hard RL environments (delete-and-restore)

Lee's visual: codebase squares + tests at bottom.

1. Generate complex application / environment
2. Delete a feature or files → tests fail
3. Model must re-implement however it wants
4. Verifiable reward: all tests pass

This scales ambitious frontier problems as models improve — same insight as eval half-life: when every model scores 90%, retire the eval and build harder ones.

Part 6 — Textual feedback (teacher-student mid-rollout)

Problem: RL rollouts span hundreds of thousands of tokens — grading only at the end makes credit assignment impossible (which tool call failed? which thinking block?).

Textual feedback:

1. Zoom in on one moment in the rollout
2. Teacher (same model + hint) says e.g. "Reminder: you have these tools available"
3. Nudge probabilities up/down on tokens you want

Student case from talk: tool call fails because model ignored an available tool — teacher hint fixes adherence without rewriting the whole trajectory.

Works for tool adherence, style, any RL behavior you can hint — Lee calls it very valuable for Composer training.

Part 7 — SpaceX compute: Colossus, Terafab, and Bucee's

March 2026 partnership with SpaceX for Colossus access — train large models from scratch, down to data center + chips (Terafab).

Full stack control lets Cursor parallelize multiple large training runs — moving the speed meter toward RSI-like velocity.

Where compute actually goes

Lee's allocation checklist (not just "train bigger"):

Bottleneck shift: when compute is abundant, human researchers launching/babysitting runs becomes the constraint → automate monotonous ML ops.

Part 8 — Mario, Super Mario, and agents from Slack

Lee's harness metaphor:

New primitives Lee highlights:

• Computer use — not just IDE/CLI; control the whole machine
• Slack thread subscription — agents follow threads, ping you when needed
• Agent Dropbox — slide decks and artifacts outside raw git

Research fleet on Slack

Cursor built Slack-launched experiment tools so researchers aren't bottlenecked babysitting runs. Each ML team member gets a fleet of agents that can:

• Spawn difficult RL problems
• Generate new evals from ideas
• Page you if infra blips would waste 6 hours of training

Human ↔ agent coordination for research ops — parallel to Thariq's proactive Claude Tag for product engineering.

Part 9 — Models training the next model

Lee's closing flywheel:

Every new top-level intelligence lets you distill derivative models that speed up judging, rewards, evals — both inner and outer loops.

Brain → galaxy brain meter: the whole system is bottlenecked on the smartest model. Improve that → every loop gets better → feels like recursive self-improvement.

Caveats from X (not from Lee, but relevant):

• @LoopOnChain: models are bad at deciding how to improve themselves without strict evals — and general-work evals are hard
• Will Brown's RSI joke: solved in the talk's vibe, not in the safety literature — contrast Weco's four-level RSI ladder (Level 1 claimed, Level 2 ignition not proven)

Lee's LinkedIn post on autoinstall makes the same point in product terms: Composer 2 configures RL environments (dependencies, broken setups) dramatically better than Composer 1 — each generation unlocks training the next.

X reaction — coding agent → general agent

Tejas Haveri asked why build a general model instead of coding-optimized. Lee pointed to his April 27, 2026 thread:

"It wasn't obvious to me one year ago that an excellent coding agent would also be the path to a general agent for all knowledge work. But now it makes a lot of sense."

That aligns with Grok 4.5 positioning — software engineering + data science + finance + legal on a computer — while Composer 2.5 keeps the fast coding slot.

Uday Bhaskar asked if this explains Lee's move from DevEx to Research — Lee's bio now reads model behavior / ML, consistent with owning the training flywheel, not just docs and demos.

What shipped after the talk

Lee closed: "new model out to you all here very soon… pretty notable improvement."

Within days:

The talk is the training story behind the Grok 4.5 blog post — recursive improvement is not marketing; it's Slack agents spawning evals and textual feedback on million-token rollouts.

What builders should take away

1. Two loops, not one — product feedback without inner-loop RL hardness stays serial and slow
2. Private evals matter — public leaderboard hygiene is necessary but not sufficient for agent truth
3. Eval half-life — delete-and-restore envs scale difficulty as models improve
4. Credit assignment — textual feedback beats end-of-trajectory grading for long agent rollouts
5. Compute is a portfolio — serving, judges, side runs, and eval R&D compete for the same GPU pool
6. Automate research ops — RSI velocity comes from agents running experiments, not humans clicking launch
7. Coding → general — harness-rich coding agents are the data flywheel for broader models

Related on explainx.ai

• Grok 4.5 in Cursor — SpaceXAI launch
• Cursor agent swarm economics — SQLite research
• SpaceX acquires Cursor — $60B context
• Field Guide to Fable — Thariq Shihipar AI Engineer
• Weco AIDE² — RSI ladder and reward hacking
• Boris Cherny Steps of AI Adoption
• Kr$na final 10% — demo vs polish
• Anthropic + SpaceX Colossus partnership

Official sources: YouTube talk · Cursor Grok 4.5 blog · @leerob on X

Recap based on Lee Robinson's AI Engineer stage transcript (July 15, 2026 video; posted July 16, 2026). Model names, pricing, and Cursor product details change frequently — verify on cursor.com before planning production workflows.