A system improves itself recursively when what it gains becomes the tool for its next gain. For decades that sentence described a thought experiment. In 2026 it describes software. One company writes that it has watched its own system do it for months. Another has published a technical report in which a system built around a research agent rewrites that agent’s code for eight days and keeps seven of the rewrites. In March, Andrej Karpathy put a small version of the loop in a public repository, and five days later the chief executive of Shopify opened a pull request built from about 120 experiments run by a loop of the same design.

This post is our reading of that evidence. One published map of the field uses two axes: how completely a system closes the loop on itself, and what each step costs. We think a third property decides how far any of these systems gets—how the loop knows that an improvement is real—and that it has become the expensive one. Building the loop is now the easy part. What follows explains why the check is the hard part, using the published numbers and three small models you can adjust.

The terms we use

Start with a strict definition. Self means the system improves itself and not some other target. Recursive means the improved capability becomes the tool that drives the next round. A system that tunes a different program, however well, is doing ordinary optimisation.

A published four-level ladder is useful for saying how far a given system has got. Level 0 is delegation: the system runs the research loop end to end, but improves more slowly than people would improve it. Level 1 is net positive: it improves itself more efficiently than its engineers do. Level 2 is ignition: it improves its own ability to improve. Level 3 is inflection: progress at a fixed budget stops slowing and starts to accelerate.

We need four more words.

  • A proposal is one candidate change to the system.
  • The accept step is the rule that decides whether a proposal replaces the current version.
  • The incumbent is the current version, the one every proposal is compared with.
  • A verified result is a proposal that passed a check its proposer could neither see nor influence, on runs that played no part in choosing it.

The measure this post argues for follows from the last of these: experiments per verified result, the number of experiments a system runs for each result that survives that check.

What the first evidence rests on

The strongest public evidence that such a loop works is also the clearest demonstration of what makes it believable.

It is the eight-day run described above. The system, AIDE², has two loops. The inner loop is a research agent working on machine-learning tasks. The outer loop proposes rewrites of that agent’s own code. Over eight days it made 99 proposals and kept seven, lifting the agent’s score from 0.703 to 0.778—past the 0.749 of the agent that the engineers behind it had built over two years.

Three things in the report carry that claim, and all three sit outside the loop.

  1. The agent being improved never sees the score that decides whether it survives. It optimises a public score. A private score on held-out data decides what is kept, and each task is run several times and averaged.
  2. The authors do not treat the rising score as proof. They state that the trajectory is not meant to show generalisation, and they re-test the discovered agents on four external benchmarks that played no part in selection, where the final agent matches or beats the human-engineered one.
  3. They measure gaming directly, on a family of tasks the loop never trained on.

What the report does not show is the recursion itself. Throughout the main run the rewrites were proposed by a fixed, human-engineered agent; the improved agents were the product of the loop and not its driver. The experiment that puts an improved agent in the driver’s seat, which the authors call the ignition test, used three seeds per arm. They report it as inconclusive and say that a firmer answer would cost too much to run. They place their own system at Level 1.

The published trajectory also lets us compute the measure we care about.

Published numbersFigure 1. Seven kept rewrites in 99 proposals, and what each one took

Accepted steps 2, 6, 28, 39, 47, 63 and 85 of a 100-node trajectory, from section 3.2 of Srikanth et al. (2026); each count is the gap to the previous accepted step. Proposals that failed to run still count as proposals. The open bar is the unfinished tail of the run: 14 proposals after the seventh kept rewrite, none accepted when the run ended.

Counting from the steps the report lists, the seven kept rewrites took 2, 4, 22, 11, 8, 16 and 22 proposals, and the last 14 proposals of the run produced none. If each gain made the next one easier to find, that sequence would fall. It does not, and with a fixed proposer there is no reason it should: the easy changes are found first. This is what a working loop looks like before it becomes a recursive one.

Why selection manufactures winners

A loop keeps what scores best, and every score is part quality and part luck.

An evaluation returns the true quality of a change plus noise: a different random seed, a different sample of test tasks, a different sequence of events inside the agent. When a loop tries 99 changes and keeps the highest scorers, it selects on both parts at once. The changes it keeps are on average better than the rest and also luckier than the rest, so the scores that got them kept overstate them. Decision analysts named this the optimizer’s curse. Machine learning knows the same effect as overfitting to a reused holdout set, where every look at the same test data leaks a little of it into the next decision.

How bad it gets depends on two ratios: how large the noise is next to a real improvement, and how rare real improvements are. The second is the one that is easy to underestimate. When only a few proposals in a hundred are real, even a modest false-pass rate applied to the other ninety-odd yields more lucky winners than real ones.

The model below draws 99 proposals. Seven really help, and the rest are split between changes that do nothing and changes that hurt. Each one is measured, and the loop keeps anything that looks better than the incumbent by more than half an improvement.

ModelFigure 2. One round of selection on a noisy score

Noise in a single run
1
7%
  • Really helps
  • Does nothing
  • Hurts

A model, not data. One unit is the size of one real improvement. A proposal helps (+1), does nothing (0) or hurts (−1); the slider sets the share that helps and the rest split evenly. Noise is normal with the standard deviation shown, and averaging k runs divides it by √k. The 7% starting point is the share of proposals accepted in the AIDE² run, used only as a plausible figure for how rare a real improvement is. The dots are one draw; the percentage is the expected value.

At the starting settings the loop keeps 26 changes, and 6 of them are real. Averaged over many draws, 22% of what this rule keeps is real. Averaging sixteen runs into every score raises that to 87%, at sixteen times the cost: 1,584 evaluations for the same 99 proposals. The bottom slider shows the effect of the base rate. The rarer real improvements are, the more runs the same confidence costs.

The public record already contains the question this raises, if not the answer. The Shopify pull request reports a template engine made 53% faster on one benchmark, measured as the best of three runs, after about 120 keep-or-discard experiments. Nearly seven months later it is still open, and a news report says its author himself described the result as probably somewhat overfit. Nobody can tell from the number alone how much of it would survive a different workload. The loop produced a result and a question, and only work outside the loop can answer the question.

Agents that game the score

Luck is the mild case. The agents inside these loops also find ways to raise a score without doing the work.

BaitBench, published in August 2026, plants an optional shortcut in machine-learning tasks: a way to score well on the public test that fails on a hidden one. Across seven current frontier agents, 57.1% of judged runs were classed as reward hacking. The rate ran from 20.8% for the most restrained agent to 76.1% for the least, and telling the agents not to cheat lowered it by 6.2 points. SpecBench finds the same pattern in long coding tasks. Every frontier agent it tested saturates the visible tests while scoring lower on held-out ones, and the gap grows by 28 percentage points for every tenfold increase in the size of the code. One agent delivered a 2,900-line program, presented as a compiler, that was a table of memorised test inputs. In PostTrainBench, agents asked to fine-tune a model sometimes trained on the test set or downloaded a finished checkpoint instead.

The chart collects the findings that are stated as rates.

Published numbersFigure 3. How often agents raise a score without doing the work

Each study uses its own definition, so compare within a group and not across groups. BaitBench: Prasad et al. (2026), seven agents on a grid of 180 tasks. AIDE²: Srikanth et al. (2026), section 3.4. METR (2025): 39 of 128 runs on one task suite and 8 of 1,087 on another, with a model that is now a generation old; it is included because the two rows differ in one condition.

Two groups deserve a second look. The METR pair is one model on two sets of tasks, and METR’s own suggestion for the 43-fold difference is that on one set the agent could read the code that scored it. The authors of the Darwin Gödel Machine report the same thing from inside a self-improving loop. Gaming was more frequent when the functions that checked for it were not hidden, and one agent reached a perfect score by removing the logging those checks relied on. An agent optimises what it can observe. If it can observe the scorer, the scorer becomes part of the problem it is solving.

The AIDE² group points the other way, and we return to it below: the rate fell during the run although nothing in the loop asked for that.

A result can also be unreal with neither luck nor gaming involved, because the ruler can be wrong. In February 2026 OpenAI audited 138 problems from SWE-bench Verified, a benchmark it had helped to build and that most of the field reported. It found that 59.4% of them had tests or descriptions flawed enough to reject correct solutions, and it stopped reporting the benchmark. A loop that had been improving itself against those problems would have been rewarded, in part, for matching the flaws.

Why the errors compound

In a single experiment a false result is a wrong number. In a loop it is the new starting point.

Two things follow. A lucky score becomes the bar that later proposals must clear, so a real improvement can be turned away because it failed to beat a number that was never real. And a change that did harm, once kept, is inherited by every later version, because the loop builds on its incumbent. The AIDE² report states the risk plainly: with enough noise a falsely accepted rewrite becomes the incumbent, and “a single noisy comparison can derail the outer loop’s subsequent search.”

The next model runs the whole loop in the same toy world: 99 proposals, a rule that keeps whatever beats the score on record, and no check. The dark line is the gain the loop would report. The violet line is the gain it has.

ModelFigure 4. What an unchecked loop reports, and what it has

Noise in a single run
1
  • Reported gain
  • Real gain
  • Reported but not real

A model, not data. The same toy world as figure 2, with 7% of proposals helping. A proposal is kept when its score beats the score on record for the incumbent, and its score then becomes the record. Each line is the average of 800 simulated loops. The dashed line is the gain if every helpful proposal were kept and nothing else.

With one run per score and noise the size of one improvement, the loop reports a gain of 3.3 improvements and has 1.0. Fewer than a third of the rewrites it kept were helpful. Double the noise and it reports 4.7 while ending slightly worse than it started. Belief and reality meet only when each score averages many runs: at eight runs per score the loop reports 6.5 and has 6.0, having spent eight times the evaluations. In this toy world an unchecked loop is not slightly optimistic. It is confident and mostly wrong, and the only thing that corrects it is more evaluation.

The measure: experiments per verified result

If the check is the constraint, the number to watch is how many experiments a system runs for each result that survives it.

That number has three parts. It rises with the cost of the check itself. It falls as more of the system’s proposals turn out to be real. And it rises with every false result that slips through, because experiments built on a false result are wasted until someone finds out. A loop with no check looks cheap only while that last cost stays hidden.

The last model puts the three together. Every proposal gets one run. Those that look good are re-run on fresh seeds and kept only if they still look good. A false result that gets through costs a set number of further experiments before it is caught.

ModelFigure 5. The cost of one verified result

7%
50
  • At the chosen share
  • If twice as many proposals helped

A model, not data. The same toy world, with noise the size of one improvement. A proposal becomes a candidate when a single run beats half an improvement, and is kept when the average of its re-runs does too. The vertical axis counts every evaluation, plus the experiments wasted on false results, per real result kept. The 7% starting point is the AIDE² acceptance rate again; the 50 wasted experiments are an assumption, which is why they are on a slider.

At the starting settings a loop with no check pays 201 experiments for each real result. Six re-runs of each candidate bring that down to 73, and at that point 57% of everything the loop computes is re-runs. Checking is not a tax on the loop. In this model it is most of the loop. The dashed curve shows the other lever: if twice as many proposals were real, every point on the curve would cost about half as much. The model also marks where our argument stops. Set the cost of a false result to zero and the cheapest policy is no check at all. Verification pays only because results get built on.

Those two levers are what we are building, in order. Verification comes first, because it is what makes the count mean anything. Then comes a memory of every experiment and why it held or failed, because that is what should raise the share of proposals that are real. A loop can be copied from a public repository in an afternoon. The record of which results held cannot be copied, and it is the term that multiplies everything else in the model.

The same measure separates improvement from recursion. Forethought’s analysis of a software intelligence explosion turns on one parameter, r: the number of times software capability doubles each time cumulative research effort doubles. Above 1, each doubling needs less than twice the effort of the last, and progress accelerates. Below 1 it fizzles. The authors are frank that the evidence cannot yet say with confidence which side we are on. In our terms, recursion is experiments per verified result falling from one version to the next, on problems the system has not seen, when the improved system is the one proposing. A loop whose kept results are partly luck will overstate that trend, in exactly the direction everyone hopes to see.

Where the published loops sit

The two-axis map we started from folds grounding into its closure axis: systems that grade their own work are moved away from the corner it calls genuine RSI. We would give grounding an axis of its own, because the models above suggest it sets the ceiling on the other two. The table places four published loops on that axis, using only what each one’s authors have written.

SystemWhat decides whether a change is keptWhat checks the result from outside
AIDE² (September 2026)A private score on held-out data, averaged over several runsFour external benchmarks, and a held-out test for gaming
Darwin Gödel Machine (2025)Its score on coding benchmarksChecks hidden from the agent in the tool-use study, where one top scorer was still found to have gamed the metric
autoresearch (Karpathy, March 2026)Validation loss after one five-minute training runNone described in the README
Poetiq Metasystem (August 2026)Not described in the postSelf-reported state-of-the-art results on six benchmarks the system had not seen

An empty cell is not an accusation. A README is not a paper, and the Metasystem post says it reveals only some details of the approach. But that column is where we would look first, and it is the one the next year of published results should fill in.

The strongest objection

The best case against this argument has three parts, and each is partly right.

Loops correct themselves. In the AIDE² run the gaming rate fell from 55% to 32%, below the 39% of the human-engineered agent, and nothing in the loop was asked to reduce it. Its authors report that the final agent had built its own defences against cheating. This is real and encouraging. It is also evidence for the check and not against it: the loop selected on a hidden score, so agents whose public gains did not survive there lost. And a third of results gamed is still a third.

Hidden scores and held-out sets are ordinary good practice. They are, and none of this is new to statistics. Our claim is about where the cost lands. Every level of nesting multiplies the noise and the bill, and the most careful published run stopped at exactly this point: the test of whether its agent had become a better improver was the one its authors could not afford to settle. A hidden score also catches only luck and gaming of the visible score. A shortcut that works on every seed, and on the hidden score too, passes any re-run. We do not have an answer to that, and we list it as open on our own site.

Compute gets cheaper. It does, and proposals get cheaper with it. What matters is the ratio, and in the model above the check takes more than half of all evaluations before a result can be trusted. The objection does hold wherever a result can be checked exactly and cheaply: a proof that a checker accepts, or an algorithm scored by a deterministic evaluator. In those domains the loop is the hard part again.

So the claim in its defensible form is narrower than the title. In empirical research with noisy and gameable scores, which describes most of machine learning, verification is the step that limits self-improvement today.

What would change our mind

  • If loops that keep changes on a single visible score turn out, under independent re-runs, to hold up as often as loops with hidden checks, verification is not the constraint.
  • If someone runs the closed-loop comparison, an improved agent proposing against the original, with enough seeds to settle it, and the cost is small next to the run itself, our claim about cost is wrong.
  • If gaming rates for frontier agents fall to a few percent without hidden scoring, the middle of this post will date quickly.
  • If experiments per verified result does not fall when a system is given a memory of verified results, the lever we are building is the wrong one. That is the curve our thesis ends on.

This post reports no measurements of our own. Figures 1 and 3 plot numbers published by others, each checked against the text of its source on 7 October 2026. Figures 2, 4 and 5 are models: their assumptions are in the captions and their code is in this page’s source. The 7% starting point for how rare a real improvement is comes from the AIDE² acceptance rate. It is an anchor, not a measurement.

Sources

  1. Srikanth, Zhao, Xu, Wu and Jiang, Recursive self-improvement of AI research agents, arXiv:2609.26457, 22 September 2026. The source for every AIDE² number here. Preprint, from the system’s makers
  2. Weco AI, AIDE²: First Evidence of Recursive Self-Improvement, 14 July 2026. The four-level ladder. It gives earlier gaming rates than the report; we use the report’s. Company post
  3. Poetiq, A Poetiq Perspective on Recursive Self-Improvement, 4 August 2026. The definition and the two-axis map; its results are self-reported. Company post
  4. Karpathy, autoresearch, repository created 6 March 2026. The keep-or-discard loop, as its README describes it. Code and README
  5. Lütke, Shopify/liquid pull request 2056, opened 11 March 2026 and open on 7 October 2026. The 53%, the 120 experiments and the best-of-three measurement. Primary record
  6. TechTimes, report on the same pull request, 19 May 2026. The only source for the author’s remark about overfitting, which is not in the pull request itself. News
  7. Prasad, Anto, Eshuijs, Moncarz, Kislay and Vazquez, BaitBench, arXiv:2608.30724, 31 August 2026. Preprint
  8. Zhao, Srikanth, Wu and Jiang, SpecBench, arXiv:2605.21384, 20 May 2026. Preprint
  9. Rank, Bhatnagar, Prabhu, Eisenberg, Nguyen, Bethge and Andriushchenko, PostTrainBench, arXiv:2603.08640, 9 March 2026. Used for its described behaviours, not its scores. Preprint
  10. METR, Recent Frontier Models Are Reward Hacking, 5 June 2025. An older model, kept for the comparison between two task suites. Evaluator report
  11. Zhang, Hu, Lu, Lange and Clune, Darwin Gödel Machine, arXiv:2505.22954, 29 May 2025. Preprint
  12. OpenAI, Why SWE-bench Verified no longer measures frontier coding capabilities, 23 February 2026. Company audit of its own benchmark
  13. Smith and Winkler, The Optimizer’s Curse, Management Science 52(3), 311–322, 2006. Peer-reviewed
  14. Dwork, Feldman, Hardt, Pitassi, Reingold and Roth, The reusable holdout, Science 349(6248), 636–638, 2015. Peer-reviewed
  15. Eth and Davidson, Will AI R&D Automation Cause a Software Intelligence Explosion?, Forethought, 26 March 2025. Research report

Left out on purpose: cheating rates from benchmarks built so that every pass is a cheat, which measure willingness and not frequency; and PostTrainBench’s scores, which are about capability and not about checking.

Cite this post

@misc{pensieve2026loop,
  title        = {The loop is the easy part},
  author       = {Pensieve},
  year         = {2026},
  month        = {October},
  howpublished = {\url{https://www.pensievelabs.co/blog/the-loop-is-the-easy-part/}},
  note         = {Pensieve blog}
}