Inside the loop: how recursive self‑improvement (RSI) actually works

I.From proof to search: the Gödel machine gets a lab bench

The theoretical blueprint is old. Jürgen Schmidhuber's Gödel machine (2003) described a program that rewrites any part of its own code the moment it can formally prove the rewrite is beneficial. Elegant, and useless in practice: for real systems, such proofs are unobtainable. The 2025 breakthrough was conceptual, not just technical — replace proof with empirical search. Sakana AI and UBC's Darwin Gödel Machine (DGM, May 2025) keeps an archive of coding agents, samples one, asks a foundation model to write an "interesting new version" of it, then runs the variant against a benchmark. Improvements enter the archive as parents for the next round; failures are kept as stepping stones rather than discarded, because a mediocre variant sometimes carries the mutation that makes a later descendant excellent.

That is the entire anatomy, and it recurs in every system in this brief: generate a variant → evaluate it against an objective score → select and archive → repeat, with the improved system now doing the generating. The recursion is the last clause. A better coding agent writes better modifications to coding agents; that is what separates RSI from ordinary automated tuning.

II.Four loops that run today

Scaffold self-modification. The DGM never touches the neural network. It rewrites the scaffold — the tools, prompts, memory management, and control flow wrapped around a frozen model — and that alone took SWE-bench from 20% to 50%. The lesson: a large share of "agent capability" lives in ordinary code, which is exactly the thing current AI is best at improving.

Evolutionary program search. DeepMind's AlphaEvolve (May 2025) pairs Gemini models proposing code mutations with automated evaluators scoring every candidate, and an evolutionary database deciding which programs seed the next generation. It found a 48-multiplication algorithm for 4×4 complex matrix multiplication — the first improvement on Strassen's construction since 1969 — and, on more than 50 open mathematical problems, matched the best known solution in ~75% of cases and improved it in 20%. The loop also closed on its own infrastructure: a discovered scheduling heuristic recovers 0.7% of Google's worldwide compute, and kernel optimizations cut Gemini's own training time by 1% — AI speeding up the training of the AI that powers it.

Self-generated training data. The lineage starts with STaR (2022): have the model generate reasoning chains, keep only the ones that reach the right answer, fine-tune on those, repeat. Filtered self-generation is now a standard stage of frontier post-training — the model's own verified outputs become its curriculum.

Weight-level self-editing. MIT's SEAL (June 2025) goes where the others don't: the model writes its own fine-tuning data and optimization instructions ("self-edits"), applies them as gradient updates to its own weights, and is trained — by reinforcement learning whose reward is the updated model's downstream performance — to become better at writing self-edits. This is the loop operating on the substrate itself, though so far only at research scale.

Around all four sits the crudest and most consequential loop: AI doing the engineering labor of AI development. Anthropic disclosed in June 2026 that Claude authors over 80% of the code merged into its own codebase, and Sakana's AI Scientist had a machine-generated paper published in Nature in March 2026.

III.The verifier is the engine

Notice what every example above has in common: a cheap, objective, automated grader. SWE-bench variants are scored by unit tests. AlphaEvolve's candidates are scored by executing them — a matrix algorithm either uses 48 multiplications and produces correct products or it doesn't. STaR keeps rationales that hit the right answer. SEAL's reward is measured benchmark performance. Self-improvement is not a property of the model; it is a property of the feedback loop, and the loop is only as good as its verifier. Where verification is instant and exact, the generator can propose millions of candidates and the loop converts compute into capability. Where verification is expensive, subjective, or gameable — "is this research direction promising?", "is this proof insightful?" — the loop stalls or, worse, optimizes the metric instead of the goal (Goodhart's law, which in this literature appears as reward hacking).

This is why the cleanest existence proof of RSI predates language models: AlphaZero (2018) reached superhuman strength in chess, shogi and Go from random play, using nothing but self-play — because a game provides a perfect, free verifier (the rules) and unlimited synthetic data that never degrades. The open research question of the decade is how much of the world can be made to look like Go: formal math (proof checkers), software (test suites), and increasingly wet-lab science with automated assays are being converted into verifiable environments precisely to feed this loop.

IV.Where the loop breaks

Three published results bound what today's loops can deliver. First, the sharpening limit. A theoretical treatment by Microsoft Research and academic collaborators (December 2024) argues that model-only self-improvement works by concentrating probability mass on high-quality outputs the model already latently contains — amortizing expensive inference-time search into the weights. That reliably converts a slow, erratic model into a fast, consistent one; it does not, by itself, produce knowledge outside the model's coverage. Genuine novelty in current systems enters through the verifier and the environment (executed programs, test results, proof checkers), not through introspection.

Second, model collapse. Training generations of models on their own unfiltered outputs makes the tails of the data distribution disappear first, then degrades everything — the Nature result of July 2024. The published mitigation is anchoring: retaining even ~10% original human data largely averts collapse, and verified-only synthetic data (the STaR filter) avoids the mechanism entirely. Collapse is a real failure mode of careless recursion, not a proof that recursion fails.

Third, the experiment bottleneck. Whatever the loop proposes must be tested, and at the frontier the tests are training runs. Whitfill & Wu (August 2025) estimate that if research compute and cognitive labor are complements — their frontier-experiments specification finds exactly that — then a million automated researchers still queue for the same GPUs, and the loop's speed is set by hardware, not intelligence.

V.The substrate gap

Put sections II and IV together and the current frontier becomes precise: today's loops improve everything around the model far more easily than the model itself. Scaffold search (DGM) and program search (AlphaEvolve) are safe to run at scale because a bad candidate just scores poorly and is discarded; nothing persistent is damaged. Weight-level loops are harder for exactly the reason they matter: gradient updates are persistent, entangled, and can silently erase existing capabilities (catastrophic forgetting), which is why SEAL-style self-editing remains a research demonstration while every frontier lab still puts humans in charge of the training run. The plausible path — visible in METR's measured doubling of autonomous task horizons every ~89 days — is not a sudden hand-off but a widening of what the outer loop is trusted to touch: first code, then training data, then hyperparameters and architectures, last of all the weights.

VI.How it plays out: three scenarios

Horizon 2026–2030. Probabilities are analytical judgment, not measurement.