You keep seeing the same words from OpenAI, Anthropic, and other neolabs. Auto-research. Recursive Self-Improvement (RSI). Self-improving agents. Autonomous post-training. Another $1B funding round, another speedrun record, another “no human in the loop” claim.
Jeff Dean just left Google after 27 years with Sanjay Ghemawat, Oriol Vinyals and Quoc Le to found Discovery Loop — a public benefit corporation whose explicit goal is to automate the full experimental cycle (hypothesis → experiment → evaluation), starting with ML research itself.
Read the Discovery Loop announcement on X.
And they aren't the only ones betting on RSI this year: Core Automation (Jerry Tworek, ex-OpenAI), Recursive (Jeff Clune), and Mirendil — ex-Anthropic researchers who raised a $200M seed at a $1B valuation to automate AI research itself. The firehose is only getting louder.
Most of these announcements are not about the same thing. They sit in different places on one simple axis: how expensive is verification?
That single number decides which part of the research loop you can actually automate, and therefore which bet you are making about recursive self-improvement.
What RSI actually requires
Operational definition: frontier AI systems developing their successors, given enough resources. (For the Good-to-Yudkowsky lineage, see Weng 2026.)
Scope: AI research improving AI. Discovery Loop's roadmap runs on through hardware, drugs, and clean energy — this map covers its first target: ML research itself.
The loop is the same one human researchers run: propose → execute → verify → feed the result into the next round.
The price of the “verify” step stretches across nine orders of magnitude:
- milliseconds (exact kernel or math verifier)
- minutes (nanoGPT / nanochat training run)
- weeks (real post-training campaign)
- months + nine figures (frontier pretraining)
Verification cost is the ruler. Everything else follows from it.
Three bets currently called “RSI”
Bet 1 — Cheap world: automate the ideas
Where verification is almost free, you can afford thousands of attempts. So you iterate on the hardest stage: proposing better ideas.
AlphaEvolve evolves programs against exact evaluators. Recursive's system runs the full research loop on nanoGPT and nanochat speedruns (minutes per run). Most startups live here because they have no frontier pipeline to accelerate — idea generation is the only asset worth building.
Strength: you can measure genuine ideation, not just execution. Catch: every idea is certified only by a cheap verifier. The standing worry is that ideas fancy in miniature die on arrival at 30B+.
Bet 2 — Expensive world: automate execution, piece by piece
Inside a real frontier pipeline every experiment burns GPU-hours, so you cannot search freely over ideas. Instead you automate the stages whose value can be proven one component at a time: data agents, sweeps, eval pipelines, research code.
This is where the big labs actually are. Most of the work is internal and quiet. Frontier labs already report that the large majority of their code is model-written. It is the least glamorous camp and, right now, the most real compounding happening.
Ceiling: pure execution automation converges to excellent pipeline tooling. Humans still hold both ends of the loop — ideas and final judgment.
Bet 3 — Pay the full price: bet on the seam
Thesis: the halves cannot be advanced separately. The hard part is the interface between ideas and verification, so keep them coupled on real models even while every component still lags humans.
Currently one clear public occupant: A-Evolve-Training ran autonomous post-training of a 30B model across four self-directed rounds, reaching 0.86 against the top human team's 0.87 on a public leaderboard (8th of ~4,000). Mid-run the system detected its own metric decoupling from the external target and rewrote its search policy — the first empirical evidence that the seam is where things actually break. The same infrastructure has closed the loop at 120B and 550B.
Caveats: still post-training only; the evolver itself runs on existing frontier models. The next milestone is written into the thesis: end-to-end train bigger, better models.
How far are we, really?
RSI on this map is not progress inside either world.
It is the gap between the two worlds closing — either cheap-world ideas proving they transfer, or the expensive world's provable surface expanding until it covers ideation.
Current record:
- Artifacts have crossed. Kernels born under a millisecond verifier now run inside production training stacks.
- No research idea has made the crossing yet. Speedrun records are real and unvalidated at scale — both at once.
- Execution is deep but piecewise. Humans still own the ends of the loop.
- The full loop has closed once, at 30B post-training scale. Frontier pretraining remains a verification bill nobody can pay.
That empty corner is the honest answer to “how far are we?”
The filter you can keep
Next time an auto-research announcement drops, ask three questions:
- Which stage of the loop does it automate?
- What does its verification actually cost?
- Did anything cross — did a result born where verification is cheap get adopted where it is expensive?
If you can answer all three, you know exactly what was claimed.
If you can't, neither can they.