What Would Count as Recursive Self-Improvement?

Louis-Antoine Mullie · August 2026

Claims of recursive self-improvement are cropping up everywhere. But when is what’s measured more than just a better benchmark score?

An agent is left running overnight on a codebase, under a fixed compute budget. It tweaks a learning rate, adjusts a schedule, and validation loss drops. In the morning, the score is better. An outer-loop agent is pointed at the inner-loop’s prompt. The outer loop rewrites the inner loop’s search policy. The score goes up again. Is this recursive self-improvement?

Both gains look identical on a before-and-after comparison. But they are entirely different phenomena. The tuned learning rate is an installed asset. It’s a better set of tires. It can be reused, but it does not make the mechanic any faster. The rewritten search policy might make the mechanic faster. If it generates better modifications, and those modifications improve the same process, the effect compounds.

The first case is just ordinary optimization with an LLM in the loop. The second case is what the literature actually meant by recursion. A third possibility, of course, is that the gain has nothing to do with the system improving at all. You just changed the benchmark the scoring rule, or gave the agent more compute.

Sixty Years of Vibes

Ideas of recursive self-improvement precede the term by decades. Good (1965) hinted at how “an ultraintelligent machine could design even better machines; there would then unquestionably be an ‘intelligence explosion’.” A feedback loop where design capacity feeds its own growth. Good didn’t define the capacity or the feedback.

Yudkowsky coined the term. General Intelligence and Seed AI (2001) defines a seed AI as “capable of self-understanding, self-modification, and recursive self-enhancement.” The 2008 essay of that name talks about improvements “large enough to cascade into other improvements,” folding differential equations in on themselves to “flatline or blow up.” This says little about how the system is actually improving.

Schmidhuber’s Gödel machine (2003/2007) is a first mathematically rigorous treatment. It rewrites any part of its code when it finds a mathematical proof that the rewrite raises its expected utility. It is provably beneficial self-modification. But it’s a definition by construction: it’s recursively self-improving because it was built exactly that way. It gives no test for an arbitrary neural net in the wild.

Fast forward to the 2020s, and discussions turned to empirical testing. Language models refine their own outputs (Self-Refine), train on their own data (self-rewarding language models), rewrite their own code (Darwin Gödel Machine), and run overnight on research harnesses. Startups put “recursive” in their name. Labs put RSI on their roadmaps. Threads report “first experimental evidence,” but underneath the hype, the metric is still an ordinary benchmark delta.

As Cunningham (2026) pointed out, most published definitions of RSI boil down to a simple feedback condition:

\[\frac{\partial}{\partial A}\,\dot A(L,A) > 0 .\]

Every discovery makes the next discovery somewhat easier. This is true of a better retrieval index, a tuned AdamW schedule, and a prompt that compresses history. Explosive conclusions need the much stronger super-exponential condition \(\partial \ln\dot A / \partial \ln A > 1\).

Feedback, autonomous progress, and explosive growth are three totally different properties. This motivates finding an estimand that is positive only when a modified improvement mechanism produced the gain.

Measuring “Intelligence” on a Scale

You can’t measure an explosion without a scale, and “intelligence” is not a scale. A more practical approach is to index the commitments. An evaluative frame \(\Theta\) specifies a task distribution \(\mathcal D\), utilities \(u_g\), and a measurement protocol. Let \(\Pi_\Theta(x,b)\) be the policies executable from state \(x\) within resource budget \(b\). Resource-bounded capability is:

\[\mathcal{C}_\Theta(x,b) = \sup_{\pi\in\Pi_\Theta(x,b)} \mathbb{E}_{g\sim\mathcal D}\!\left[u_g(\pi)\right].\]

Translation: At a strict budget \(b\), what’s the highest expected score the agent can achieve?

This definition results in a family of scalars indexed by \((\Theta,b)\). Two systems might tie at a $10 compute budget, but one dominates at $5 because it uses a compiled procedure while the other wastes time reconstructing the answer from scratch. A single leaderboard point—time-to-GPT-2, SWE-bench, whatever—cannot show this. A curve over budgets can. If a demo reports one number at one budget, it hasn’t made a capability claim yet.

The Frozen Baseline

How can we distinguish between “the agent improved the model.” and “the agent improved the process that improves the model.”?

Suppose a modification \(a\) changes both an object-level component and the machinery used to produce later modifications. Write the resulting state as \(x_a=(o_a,m_a)\).

• The object \(o_a\) is everything installed by the update: code, weights, tools, indexes. (The tires).

• The mechanism \(m_a\) is the proposer, verifier, evaluator, and the outer loop. (The mechanic).

A conventional evaluation compares the new state \(x_a\) with the old state \(x_0=(o_0,m_0)\). Beating a baseline (e.g. a hand-tuned harness) on held-out tasks is evidence that the update did something. It is not, by itself, evidence that the new mechanic is actually better at their job going forward.

To prove that, you need the frozen baseline. You keep the shiny new tools (\(o_a\)), but you force the agent to use the old mechanic to generate the next set of changes.

Let \(\mathcal K_m(do'\,dm'\mid o,m)\) be the kernel of one improvement epoch. The frozen kernel forces every later epoch to use the baseline mechanism while leaving the object state, tasks, and randomness untouched:

\[\mathcal K^{[m_0]}(do'\,dm'\mid o,m) := \mathcal K_{m_0}\!\left(do'\times\mathsf M\mid o,m_0\right)\, \delta_{m_0}(dm').\]

Evolving \((o_a,m_0)\) under this kernel gives the frozen baseline. It must face the same exact challenges and pay the same replacement costs, but it commits to its answers before seeing what the new mechanism invents. (If you let it peek at the new inventions, you’re asking “could the old harness copy the winner after the fact?” which is interesting, but it’s not RSI).

Writing \(J_H^{K}(o,m)\) for expected continuation value over \(H\) improvement epochs, the recursion premium of the installed transition \(a\) is:

\[\mathfrak R_H(a;x) = J_H^{\mathcal K}(o_a,m_a)-J_H^{\mathcal K^{[m_0]}}(o_a,m_0).\]

Both terms start with the exact same tools (\(o_a\)). Only the mechanic differs. A positive \(\mathfrak R_H\) measures the value of reusing the new mechanism.

If the agent just found a killer hyperparameter, \(\mathfrak R_H = 0\). The frozen baseline has the same hyperparameter and loses nothing by searching the old way. If the rewritten proposer actually works better, \(\mathfrak R_H > 0\). This inequality is the core of a recursive-improvement claim. What some demos call “ignition” is just asking if \(\mathfrak R_H\) stays positive.

The premium has an exact decomposition: with \(V_h^K\) the \(h\)-epoch value under kernel \(K\) and \(A_h^{K_0,K}(x)=\int\!\left[r(x,y)+V_{h-1}^{K_0}(y)\right]K(dy\mid x) -V_h^{K_0}(x)\) the one-step advantage of the new mechanism over the frozen prediction from the same state:

\[V_H^{K}(x)-V_H^{K_0}(x) = \mathbb{E}_{K}\!\left[\sum_{t=0}^{H-1}A_{H-t}^{K_0,K}(X_t)\,\middle|\,X_0=x\right].\]

This is the finite-horizon performance-difference identity from MDP theory. The whole premium is just the sum of per-epoch advantages. If the new mechanism is never strictly better than the frozen prediction, the premium is zero.

If you have an autoresearch stack with a clean harness boundary, you can build the frozen baseline by reverting the improvement code. If you have a tangled neural system where object and mechanism can’t be cleanly spliced, intervals of premium values can still be identified.

Did It Learn, or Just Cache?

Some modifications make known outcomes cheaper; others make new outcomes reachable. Both make benchmark scores go up. How can we tell which is which?

For each protocol \(\iota\) and budget \(b\), let \(\mathcal O_x^\iota(b)\) be the set of outcome distributions attainable from state \(x\). The collection

\[\mathfrak G(x) = \bigl(\mathcal O_x^\iota(b)\bigr)_{\iota,b}\]

is the resource-indexed attainable-law profile.

Building an index or compiling a procedure lowers the resource cost of behavior that was already available. If \(\kappa_x^\iota(\mu)\) is the least budget at which outcome law \(\mu\) becomes attainable, lowering means \(\kappa_{x'}^\iota(\mu)\leq\kappa_x^\iota(\mu)\).

Representation growth happens when an outcome becomes attainable that was impossible under the previous repertoire:

\[\mu\in\mathcal O_{x'}^\iota(b) \quad\text{and}\quad \mu\notin\mathcal O_x^\iota(b)\]

Lowering moves a resource frontier; representation growth changes its support. A “new search policy” is syntactical fluff until the profile shows outcomes the old language could not reach.

The same profile gives a set-valued companion to the recursion premium. Writing \(E_a^\iota(b)\) for the improved system’s attainable set at budget \(b\) and \(F_a^\iota(c)\) for the frozen baseline’s at budget \(c\), the directed resource distortion

\[\Delta_a(b) = \inf\left\{\,c : E_a^\iota(b)\subseteq F_a^\iota(c) \ \text{for every anchor }\iota\,\right\}\]

is the smallest budget at which the frozen baseline matches every future available to the improved system at budget \(b\). The overhead \(\Delta_a(b)-b\) prices what reverting the mechanism costs. This replaces the unanswerable “how much smarter did it get?” with “how much extra compute does the old machinery need to keep up?”

Surviving the Reboot

A gain seen during one task is useless if it vanishes when working memory resets. Good’s loop requires improvements that persist into the next design cycle.

For states \(x_0,\ldots,x_T\), define \(\Delta_t=\mathcal{V}(x_t)-\mathcal{V}(x_{t-1})\). Then

\[\sum_{t=1}^{T}\Delta_t = \mathcal{V}(x_T)-\mathcal{V}(x_0).\]

The intermediate values cancel. The identity fixes the net endpoint difference. If the path contains losses,

\[\sum_{t:\Delta_t>0}\Delta_t = \mathcal{V}(x_T)-\mathcal{V}(x_0) - \sum_{t:\Delta_t<0}\Delta_t.\]

Repeatedly acquiring, losing, and reacquiring the same skill produces a massive sum of positive increments with zero endpoint change. For RSI, we only care about the right side of the equation.

Historical Comparisons

A Gödel machine embeds as a special case of this framework: proposal is proof search; admission requires a proof in the installed theory. But a Gödel machine relies on axioms and switch proofs. Real-world agents rely on statistical evidence and messy test suites, which is why “Darwin” variants that drop the proof requirement do not inherit Schmidhuber’s guarantees just by borrowing his title.

AIXI lives at the opposite pole of the spectrum. An ideal Bayesian expected-reward optimizer updates its posterior forever and gets highly capable, but its learning algorithm never changes. It has a recursion premium of exactly zero. The same applies to an autoresearch harness that just reads more experiment logs without rewriting its own code. More information is not a rewritten improver.

A Candidate Experimental Protocol

Here is a protocol sketch for identifying (at least some forms of) RSI.

1. Fix the tasks, utilities, stopping rules, and budgets before comparing systems. Do not retune the eval after seeing the winner.

2. Checkpoint the pre-modification object and improvement mechanism.

3. Install the proposed change, retaining the complete post-install object.

4. Construct the frozen baseline before exposing it to outputs produced by the new mechanism.

5. Run the modified and frozen systems on matched future improvement tasks.

6. Estimate the premium \(\mathfrak R_H\) and distortion \(\Delta_a(b)\).

7. If you can’t cleanly revert the mechanism, at minimum, report the identification interval.

What a Positive Result Could Look Like

Consider an illustrative experiment with 200 paired continuations. Every pair receives the same post-install object \(o_a\), task sequence, random seed, and resource schedule. One member uses the modified mechanism \(m_a\); the other uses the frozen mechanism \(m_0\). Utility is scored on a 0–100 scale. The immediate post-install score is 66.4 for both systems, up from 60.0 before the install. That 6.4-point gain belongs to the installed object and is therefore not evidence of recursion.

In the table below, "continuation gain" is expected improvement relative to the common post-install state. For those rows, the recursive gap is improved minus frozen. "Matching budget" is the budget required to reproduce the improved system's attainable set; for those rows, the gap is frozen minus improved.

Measure	Index	Improved	Frozen	Recursive gap	95% CI
Immediate task score	\(h=0\)	66.4	66.4	0.0	\([-0.3,\,0.3]\)
Continuation gain	\(h=1\)	4.2	3.7	0.5	\([-0.2,\,1.2]\)
Continuation gain	\(h=2\)	9.8	7.1	2.7	\([1.5,\,3.9]\)
Continuation gain	\(h=3\)	16.9	10.2	6.7	\([5.1,\,8.3]\)
Continuation gain	\(h=4\)	24.5	12.6	11.9	\([9.8,\,14.0]\)
Matching budget	\(b=1\)	1.00	1.02	0.02	\([0.00,\,0.07]\)
Matching budget	\(b=2\)	2.00	2.25	0.25	\([0.12,\,0.38]\)
Matching budget	\(b=4\)	4.00	5.10	1.10	\([0.72,\,1.49]\)
Matching budget	\(b=8\)	8.00	11.60	3.60	\([2.75,\,4.44]\)

At four epochs, the estimated recursion premium is the difference between the two continuation gains:

\[\widehat{\mathfrak R}_4 = \widehat J_4^{\mathcal K} - \widehat J_4^{\mathcal K^{[m_0]}} = 24.5-12.6 = 11.9 \quad\text{utility points}. \tag{1}\]

The widening gap matters more than the final number alone. The estimated one-epoch recursive advantages are the successive increments in the premium, \((0.5,\,2.2,\,4.0,\,5.2)\). They recover the endpoint estimate exactly:

\[\widehat{\mathfrak R}_4 = \sum_{t=1}^{4}\widehat A_t = 0.5+2.2+4.0+5.2 = 11.9. \tag{2}\]

The resource comparison gives the same result in operational units. At budget \(b=8\), the frozen mechanism needs an estimated budget of 11.6 to match the improved system's attainable outcomes:

\[\widehat\Delta_a(8)-8 = 11.6-8 = 3.6, \qquad \frac{\widehat\Delta_a(8)-8}{8} = 45\%. \tag{3}\]

This pattern would be evidence of RSI under the stated intervention: no live–frozen difference at installation, a positive continuation premium after reuse, and a frozen-system resource penalty that grows with budget. It would not, by itself, establish unbounded improvement, an intelligence explosion, or even another positive premium beyond \(H=4\). Those are different hypotheses requiring longer horizons and additional assumptions.

Key Takeaways

RSI became the three-letter stand-in for takeoff for the exact same reason AGI did: the word travels much faster than the measurement.

Most public claims advanced so far measure a benchmark delta. This is misguided, as it conflates installed assets, altered machinery, and changed evaluations. Talks about "ignition" mean little when built on top of that.

Three principles can help steer towards a valid measurement: resource-indexed capability instead of “intelligence”; a frozen-baseline intervention instead of a before-and-after comparison; and prospective attribution fixed before the mechanisms diverge.

Under those principles, recursive self-improvement is an estimand:

\[\mathfrak R_H(a;x) = J_H^{\mathcal K}(o_a,m_a)-J_H^{\mathcal K^{[m_0]}}(o_a,m_0),\]

With a frozen baseline, matched budgets, and strict attribution, the recursive component can be estimated. Without them, a rising score is just an aggregate performance difference. It might be great engineering. But it isn’t recursive self-improvement.

A change counts as recursive self-improvement when it persists, produces a genuine net improvement under a fixed external frame, and retaining the changed improvement machinery yields better or cheaper future improvement than a counterfactual that preserves the change’s installed object-level effects but restores the prior improvement machinery.