Recursive Self-Improvement: Theory, Demonstrations, Limits

Abstract. Recursive self-improvement (RSI) names a hypothesis about compounding feedback: a system that improves its own ability to improve, where each iteration accelerates the next. The phrase is older than modern AI, but it has been recruited to describe a heterogeneous set of contemporary systems — prompt optimizers, self-debugging coding agents, mutable-scaffold loops, algorithm-discovery engines — most of which demonstrate bounded local optimization under fixed model weights rather than the unbounded recursion the theory describes. This article separates three claim-levels (local self-optimization, scaffold-level recursive modification, classical weight-mediated intelligence explosion), audits the empirical landscape through May 2026 against the mechanism that classical RSI actually requires, and sets explicit thresholds for what evidence would justify moving any present-day system from the second category into the first.

Coverage note: verified through May 2026.

1. What "recursive self-improvement" actually claims

A loop is not automatically recursive. A system that iterates on its outputs is doing local optimization. A system that iterates on the rules by which it iterates is doing recursive modification. A system that iterates on the rules by which it iterates and thereby increases the rate, breadth, or autonomy of subsequent iterations is doing recursive self-improvement in the sense that matters for the classical literature. The three are routinely conflated in popular accounts of "self-improving AI" and need to be kept separate from the start.

Three claim-levels span the contested territory:

Claim level	What is modified	What is held fixed	Evidence circa 2026
Local self-optimization	The current answer, plan, or artifact	Everything else (prompts, scaffold, evaluator, model weights)	Common — Self-Refine, Reflexion, Self-Debugging
Scaffold-level recursive modification	Prompts, tools, agent code, memory, evaluation harnesses; possibly the mutator itself	Base model weights, outer-loop validator	Emerging — Promptbreeder, STOP, ADAS, Darwin Gödel Machine, AlphaEvolve
Classical RSI (intelligence explosion)	The mechanism that produces general cognitive capability, including model training and successor design	Only the external physical environment	Not publicly demonstrated

The strong reading of "RSI" — the one that drives the alignment-theory discussion — refers to the third row. The weak reading — common in engineering posts and capability narratives — slides freely between the first and second. The article-shape of the topic depends on refusing that slide.

Two definitional moves do the most work. The first is to require that a self-modification actually persist and inherit: a change made in generation N must be available to generation N+1 in a form the system can build upon, not erased at the end of a run. The second is to require meta-improvement: generation N+1 must improve at finding, validating, and integrating future improvements — not merely score higher on a fixed task. Without persistence and meta-improvement, "self-improvement" reduces to test-time search.

These are the operational variables every empirical claim in §4 will be classified against:

• Mutation substrate: what changes — answer, prompt, scaffold, tool, evaluator, data, weights
• Evaluator: who or what scores the change — fixed benchmark, human, executing environment, another model, the system itself
• Integration mechanism: how a passing change becomes part of the next generation — archive, code merge, prompt library, weight update
• Persistence: whether the change survives the run
• Transfer: whether the change helps on tasks outside the one that produced it
• Autonomy: how much human intervention the loop requires per generation
• Compounding rate: whether the rate of finding further improvements increases across generations

A system that improves on a benchmark by running a fixed Reflexion loop on each instance scores zero on persistence, transfer, autonomy at the meta-level, and compounding rate. A system that rewrites its own scaffold code, validates the change on an archive of held-out tasks, retains the new scaffold for the next generation, and then uses the new scaffold to find a still-better scaffold scores positively on all six. The classical RSI claim requires the second pattern at a level above scaffolds.

2. Historical framing

2.1 Good's 1965 argument

I. J. Good's "Speculations Concerning the First Ultraintelligent Machine" makes a tight, often-misremembered argument. The crucial premise is not that machines will become very smart but that machine design is itself an intellectual activity. If an ultraintelligent machine — defined as one that "can far surpass all the intellectual activities of any man however clever" — exists, then designing better machines is among the activities at which it surpasses humans. Therefore it could design a still better machine, which could design a still better one. Good's conclusion is that the first ultraintelligent machine "is the last invention that man need ever make, provided that the machine is docile enough to tell us how to keep it under control" (Good 1965).

What is doing the work in Good's argument is not "intelligence" abstractly but the closure of a specific bottleneck: human-designed machine architecture. The premise that fails most often in current systems is not the intelligence premise but the closure premise — the systems being described as recursively self-improving are not designing their own successors in any meaningful sense; they are improving the harness around a frontier model someone else designed and trained.

2.2 The foom debate

The 2008–2013 "foom debate" between Eliezer Yudkowsky and Robin Hanson made the takeoff-speed question explicit. Yudkowsky's position was that a sufficiently capable system could undergo a "hard takeoff" — recursive self-improvement compounding fast enough that there is no protracted window for external correction (Yudkowsky 2008, "Artificial Intelligence as a Positive and Negative Factor in Global Risk"; Yudkowsky 2013, "Intelligence Explosion Microeconomics"). Hanson's position was that capability growth is more like the broader history of economic and technological progress, diffuse and gradual, with discontinuous jumps unlikely because the relevant innovations are widely distributed across actors, institutions, and substrates.

The debate was not resolved empirically because the relevant systems did not yet exist. It was conceptually productive in two ways. It clarified that the disagreement is not over whether AI will be powerful but over the coupling between capability and the rate of further capability acquisition. And it forced the explicit distinction between "AI improves at things" and "AI improves at improving AI" — a distinction that the modern empirical literature continues to blur.

2.3 Bostrom's framing

Bostrom's Superintelligence (2014) reframed the question as one of optimization power versus recalcitrance. The "optimization power" applied to AI capability research is the rate at which capability-improving work gets done; the "recalcitrance" is how hard further improvement is at the current level. Intelligence explosion is the regime where applied optimization power outruns the rise in recalcitrance — where adding more search/design effort yields proportional or super-proportional capability gains.

The Bostrom framing is useful because it dissolves the binary "will RSI happen?" question into the empirical question "what is the recalcitrance curve, and what substrate dominates it?" Capability gains might be steep at one end and flat at another. The recalcitrance curve depends on what bottleneck is binding — model architecture, training data, training compute, evaluator design, scientific taste, or scaffolding around fixed models. The classical argument assumes architecture or training-mechanism design is binding and that AI is what relieves the binding. Whether that is true in 2026 is empirically open, and the article returns to it in §6.

2.4 What the classical literature does not establish

The classical literature establishes a coherent theoretical concern and a clear conditional — if a system can improve the machinery that produces its own future improvements, then the dynamics are potentially explosive. It does not establish that any present-day system has crossed that threshold, that scaffolding-level changes count as "the machinery," or that the closure premise of Good's argument is satisfied by current AI-assisted AI research. Reading the modern empirical landscape requires keeping that conditional intact, not converting it into evidence.

3. The mechanism model

The classical literature can be summarized as a recursive loop with five components. Calling something "RSI" amounts to a claim about each of them.

1. Generator. A process that proposes modifications. In modern systems this is usually a language model invoked with a prompt, possibly augmented by tools, memory, or search.
2. Substrate. The thing being modified. This is the most under-specified term in popular discussion. Candidates include: the current answer, the prompt, the agent's code, the agent's tools, the agent's memory, the agent's evaluation harness, the training data, the model weights.
3. Evaluator. A process that scores modifications. Evaluators range from cheap executable tests (compile, pass unit tests, win a Minecraft sub-goal) through fixed benchmarks (HumanEval, SWE-bench) to subjective LLM-as-judge to human review. The evaluator is the single most load-bearing component for whether a loop produces genuine improvement or merely overfit benchmark-tracking.
4. Integration mechanism. A process that turns a passing modification into part of the next generation. Without integration, "improvement" is ephemeral — the artifact exists but is discarded. Integration mechanisms include: writing to an archive, merging into a code repository, updating a prompt library, updating a skill library, or, in the strongest case, updating model weights.
5. Compounding test. Whether the improvement at generation N changes the capability of generation N+1 — its ability to find, validate, and integrate generation-N+2 improvements. This is the difference between a system that gets better and a system that gets better at getting better.

Three structural relations matter. First, the substrate and the generator can be the same component (a system that uses an LLM to modify its own LLM-invocation prompt is operating on a substrate that includes its own generator). When they are, the loop is genuinely recursive at the mechanism level even if the model weights are fixed. Second, the evaluator can itself be a substrate — a system that rewrites its evaluation harness is, by the same logic, recursive at a higher level. Third, none of these recursive properties imply compounding; many recursive loops are convergent or oscillatory rather than divergent.

The article uses this five-component taxonomy as its evidence frame in §4. Every system named in the empirical section is classified by what it modifies, what evaluates the modification, how the modification is integrated, and whether the next generation is observably better at producing further modifications.

4. The empirical landscape circa 2026

4.1 Local self-optimization at fixed weights

The largest and best-established cluster of "self-improving" demonstrations are loops in which an LLM iterates on an artifact under feedback while the model itself and the surrounding infrastructure remain fixed.

Self-Refine (Madaan et al. 2023) prompts a single LLM to produce an output, critique it, and revise it. The substrate is the current answer; the generator, evaluator, and integrator are all the same model invoked with different prompts. Across seven tasks, it reports average gains around 20 percentage points without any training. Persistence is zero — the improved output is discarded after the task — and the model has not become better at refining; it has used additional inference compute to produce a better answer on this instance.

Reflexion (Shinn et al. 2023) extends the pattern by storing verbal feedback from prior attempts in an episodic memory the next attempt can read. The integration mechanism is the memory write, and the substrate now includes the memory's contents. But the memory is task-scoped: reflections from one task do not carry to another in any structured way. The system improves within a task across attempts; it does not improve across tasks.

Self-Debugging (Chen et al. 2023) uses execution feedback to repair code: run the program, observe the output, explain the discrepancy, revise. This is closer to a genuine evaluator-driven loop because the evaluator (the executing environment) is independent of the generator. But the substrate is still the current program, and the loop terminates at the end of the instance.

Voyager (Wang et al. 2023) is the most interesting member of this cluster because it adds a persistence mechanism: discovered skills are stored as executable code in a skill library that subsequent task-solving can call. The agent uses GPT-4 as the generator, Minecraft itself as the evaluator, and the skill library as the integration mechanism. Capabilities accumulate across episodes. Voyager is therefore a partial case of scaffold-level recursive modification, not pure local optimization — it is the bridge between rows one and two of the table in §1.

None of these demonstrations refutes the classical RSI thesis, but none of them is evidence for it. They show that fixed-weight LLMs can use feedback and memory to improve outputs without further training. That is a meaningful engineering result and the foundation for many production agent systems. It is not a system improving the mechanism by which it finds future improvements.

4.2 Scaffold-level recursive modification

A second cluster modifies the scaffold itself — the prompts, agent code, search procedures, or evaluation harness that surrounds a fixed base model.

Promptbreeder (Fernando et al. 2023) evolves task prompts using mutation prompts, then evolves the mutation prompts themselves on the same task distribution. This is genuinely self-referential at the prompt level: the system modifies the process by which it modifies prompts. Persistence within a run is real (the population is retained), but the resulting prompt populations are task-distribution specific; transfer across substantially different distributions is not demonstrated.

DSPy (Khattab et al. 2023) operationalizes pipeline optimization: the user specifies a program structure and a metric, and the framework searches over prompts and few-shot demonstrations to maximize the metric. This is optimizer engineering, not self-improvement in the recursive sense — the optimizer itself is fixed. DSPy is best read as evidence that prompts and pipelines are productive substrates for optimization, not as evidence about RSI.

STOP (Zelikman et al. 2023) — Self-Taught Optimizer — is unusually relevant because it is explicit about what it does and does not show. The system is a scaffolding program that uses a language model to improve itself. The model is the generator; the scaffold is the substrate; the evaluator is a fixed downstream task. The authors are explicit that the language model is not altered, so the system is, in their own framing, "not full recursive self-improvement." It is one of the cleanest existing examples of scaffold-level recursion at the program level.

ADAS / Meta Agent Search (Hu, Lu, and Clune 2024) programs new agent architectures in code. The generator (an LLM) writes candidate agent code; the evaluator runs the agents on tasks; passing agents enter an archive that the next generation builds on. The authors report transfer of discovered agent designs across domains and models. The substrate (agent code), evaluator (task performance), and integration (archive) are clean. What ADAS does not demonstrate is meta-improvement — whether later generations find better agents faster than earlier ones. The reported gains are about what is discovered, not about the discovery rate.

Darwin Gödel Machine (Zhang et al. 2025) is the most aggressive recent scaffold-level system. A coding agent modifies its own codebase, validates changes against coding benchmarks, retains successful changes in an archive, and selects parent agents for further modification using a search procedure inspired by open-ended evolutionary search. Reported gains are substantial: SWE-bench from 20.0% to 50.0%, Polyglot from 14.2% to 30.7%. Sandboxing and human oversight are explicit; the system is not run unsupervised.

DGM is the cleanest existing case for taking scaffold-level recursive modification seriously as a phenomenon. It is also the system most at risk of being over-read. The base model is unchanged. The evaluators are static coding benchmarks. The integration mechanism is a code archive. The improvement curve — whether the rate of discovering useful self-modifications is itself increasing across generations — is not the headline metric. SWE-bench in particular has well-documented contamination risk; SWE-bench-Live was constructed in part to address it. The strongest honest reading of DGM is that scaffold-level recursive modification produces real, substantial, persistent gains on the benchmarks it was tuned against. The weakest honest reading is that it is recursive search over a hand-crafted agent codebase under a fixed evaluator.

AlphaEvolve (Novikov et al. 2025) is the most consequential algorithm-discovery system in this cluster. An LLM generates candidate code; an evaluator runs the code against a programmatic metric; passing candidates are retained and mutated further. AlphaEvolve has produced genuinely novel algorithms — including, notably, kernels that accelerated the training of the very model family underpinning the system. This is the closest publicly documented case of an AI system producing improvements that fed back into its own training pipeline. It is also tightly scoped: the evaluator is programmatic, the search is over code, and the integration into model training was a human decision to use the discovered kernels.

The cluster also includes coding-agent systems whose interface and harness improvements drive most of the reported gain. SWE-agent (Yang et al. 2024) reports that careful agent-computer interface design moves SWE-bench pass@1 to 12.5% and HumanEvalFix to 87.7%, gains attributable substantially to interface design rather than model capability. That pattern — where the scaffold is the bottleneck and scaffold improvement is the available source of capability gain — is exactly the regime in which scaffold-level RSI claims become tempting.

The honest classification of the scaffold cluster is: real recursive modification at the scaffold layer is now empirically established in narrow domains. Real meta-improvement — generation N+1 finding improvements faster, more broadly, or more autonomously than generation N — is not yet the headline metric of any public system, partly because measuring it requires preregistered protocols that have not been adopted (§7).

4.3 Capability discovery and integration pipelines

A third pattern is less academic but increasingly common in practice: a deployed system that searches for new capabilities, evaluates them, and integrates passing capabilities into its own toolset. Several open-source agent harnesses now include capability-discovery components — a discoverer surveys GitHub, newsletters, and the web for new MCPs, skills, or agent designs; an evaluator scores them against an integration-worthiness rubric; an integrator writes them into the agent's configuration. The substrate is the agent's tool and skill inventory; the integration mechanism is configuration update; the generator and evaluator are LLMs invoked with task-specific prompts.

This is the most domestically interesting case for engineering audiences because it is scaffold-level recursive modification deployed against real engineering work rather than benchmarks. It is also among the easiest cases to over-read. The base model is unchanged. The evaluator is a configured rubric vulnerable to drift and to bias toward "integrate" verdicts. The integration mechanism produces no rollback signal: an integrated skill that turns out to be inert sits in the inventory until someone notices. Most importantly, the system is not observably finding capabilities faster across generations. It is finding capabilities at a roughly constant rate, with the rate determined by the human-defined search scope and the LLM's ability to assess fit. That is useful engineering. It is not recursive acceleration.

The general pattern across deployed capability-discovery pipelines is the same. They demonstrate persistence, integration, and (sometimes) modest transfer. They do not demonstrate compounding rate. The article's strongest empirical claim is that the missing measurement — not the missing capability — is what distinguishes current deployments from RSI in the classical sense.

4.4 What none of this is

Three negative claims hold across the empirical landscape:

First, no public system has been demonstrated to improve its own underlying model weights through autonomous successor training. AI-assisted AI research is real and increasingly substantial — AlphaEvolve discovered kernels that improved training; frontier labs use AI for code review, experiment design, and infrastructure work — but the loop that closes Good's premise (the AI designs its successor) is, in public, still mediated by human researchers making the integration decisions.

Second, the recursive training of LLMs on AI-generated data is not, in itself, recursive self-improvement. Shumailov et al. 2024 showed that naive training on self-generated data produces model collapse — distributional degradation. The result does not refute RSI; high-quality synthetic data with verification and curation may avoid the collapse regime. It does refute the folk intuition that "AI generating training data for AI" is automatically a recursive improvement engine.

Third, the case for strategic significance of scaffold-level mutation does not require demonstrating intelligence explosion. A system that accelerates AI research even by a substantial constant factor — without ever entering a compounding regime — would be economically and safety-significant. The classical RSI literature is about a specific dynamic; the practical question of "how much is AI accelerating AI R&D and what are the consequences" is broader and more important than whether any particular system meets the classical definition.

5. Critiques and limits

The scaffold-as-RSI reading has serious problems. The article should name them directly rather than hedge.

5.1 The evaluator problem

Most scaffold-level systems are improving against a fixed evaluator that someone else designed. The evaluator is the part of the loop that determines what "better" means; an unimproving evaluator places a hard ceiling on improvement direction. Self-Refine optimizes for what its prompt-as-judge calls good; DGM optimizes for SWE-bench and Polyglot; Promptbreeder optimizes for the prompt-task-pair-evaluator triple it was given. In every case the evaluator is built by humans and held fixed during the run.

This matters because in the classical RSI loop the evaluator is part of what gets improved — a smarter system is a better judge of its own work. A system that improves its scaffold against a fixed evaluator is doing optimization, not recursive cognitive improvement. The systems that do mutate their evaluators (e.g., systems that allow LLM-as-judge prompts to be modified) immediately encounter the second problem: evaluator gaming. If the system can modify what counts as success, the obvious local optimum is to make success cheap.

The honest reading is that evaluator design is the binding constraint for whether scaffold mutation can produce real improvement or only metric-tracking, and that no current system has solved evaluator co-evolution.

5.2 The persistence problem

Many "self-improvement" results are not persistent in any meaningful sense. The improved Self-Refine answer is discarded. The Reflexion memory is task-scoped. The DSPy-optimized prompts are run-scoped unless explicitly saved. Voyager's skill library and ADAS's agent archive are the exceptions — they persist by design. The cluster is split, and the persistent half is small.

Persistence is necessary but not sufficient. A persistent improvement that does not change the system's capability to find further improvements is just a tool that exists now. Persistence plus inheritance — generation N+1 actually using and building on the generation-N improvement — is what makes the loop recursive.

5.3 The transfer problem

A system that improves on one task distribution may degrade on another. Most benchmark-driven scaffold optimization is silent about transfer because evaluation is task-specific. The systems that report cross-domain transfer (ADAS, DGM) report it as a feature, not as a measured curve. There is no public dataset of "scaffold improvements transferred across domains," which means there is no base rate for how often transfer happens at the scaffold level.

The classical RSI claim is fundamentally a claim about general capability growth. If scaffold-level mutation produces improvements that are domain-specific and do not transfer, scaffold RSI plateaus quickly and the loop closes within a domain rather than expanding across domains. The empirical question is open.

5.4 The autonomy problem

Every system described in §4 runs under human oversight: humans built the scaffold initially, humans curated the evaluator, humans decide when to stop the run, humans select which discovered improvements to integrate into downstream production. The autonomy claim — that the system is improving itself without human intervention — is rarely literally true. What is true is that the marginal human intervention per generation is decreasing for some systems. That is a real signal but not the same signal.

DGM, ADAS, and AlphaEvolve are all run under explicit oversight regimes. The question of what happens when oversight is removed — what the rate, breadth, or direction of improvement looks like in unsupervised long-horizon operation — is unanswered because it has not been responsibly tested. The fact that it has not been tested is itself informative: the labs running these systems consider unsupervised long-horizon operation to require safety work that has not been completed.

5.5 The contamination problem

Static coding benchmarks like SWE-bench are now part of the training data of the models being evaluated on them. This is not a small effect; it is large enough that SWE-bench-Live was constructed specifically to address it. Any RSI claim that rests on improvement against a contaminated benchmark is rhetorically vulnerable to the response "the system is rediscovering its training data."

The systemic problem is that evaluator quality and evaluator freshness are pulling apart faster than the field can rebuild them. Fresh-task evaluation is expensive and slow; static benchmarks are cheap and fast; the incentive structure pushes toward overstating gains. A serious scaffold-RSI claim has to be made against fresh tasks with documented isolation from training data, and the costs of doing so are part of why such claims are not yet routinely made.

5.6 The bottleneck problem

Bostrom's recalcitrance frame can be used against the scaffold-RSI reading. Suppose the binding constraint on AI capability growth is not scaffolding but model training compute, training data quality, or model architecture. Then improving the scaffold helps within the limits of the current model but cannot relieve the binding constraint. Scaffold-RSI saturates. The graph of capability versus generation flattens at the model's underlying ceiling.

Suppose instead the binding constraint is evaluation quality — the bottleneck on AI capability is the field's ability to score what a smarter system would do. Then no amount of scaffold mutation matters until evaluator co-evolution is solved. Again scaffold-RSI saturates.

The class of capability bottlenecks that scaffold-level RSI can usefully relieve is a subset of all possible bottlenecks. The classical RSI argument assumed the binding constraint was "human-designed architecture," and that AI relieved it. If the actual 2026 binding constraint is something else (compute, evaluation, data), the relevance of scaffold mutation to classical RSI is correspondingly reduced.

6. The substrate question: is weight mutation necessary?

A common framing of the open question is "weight-level versus scaffold-level RSI." That framing is too binary. The more useful question is which bottleneck is binding, and which substrates can be modified in ways that relieve it.

Substrate	Mutation mechanism	Bottlenecks it can relieve	Bottlenecks it cannot
Answer	Inference-time search	Specific task instance	Anything cross-instance
Prompt	Prompt optimization	Prompt-mediated capability access	Underlying model capability
Tool / Scaffold code	Code mutation under evaluator	Interface design, search procedures, tool inventory	Model architecture, training
Memory / Skill library	Persistent storage of learned content	Recall, accumulated procedural knowledge	Generative capability of base model
Evaluator / Harness	Mutation of evaluation code	Evaluation efficiency, coverage	Validity of the new evaluator
Training data	Data generation / curation	Distributional weaknesses	Architecture, compute, base model
Model weights	Continued training or successor model	Underlying capability	External evaluation, deployment

The classical RSI claim does not specify the substrate; it specifies the closure. A loop closes the Good premise if it modifies whatever is binding in a way that increases the system's capacity to find further improvements. In 2026 the publicly demonstrated systems mutate substrates above the weight level — answer, prompt, scaffold, memory, evaluator, sometimes data. The systems that mutate weights (continued training, supervised fine-tuning, RL) are run by labs as engineering processes; they are not autonomous self-modification loops.

The honest position is that the weight/scaffold distinction is a proxy for the closure question, not a substitute. Scaffold-level mutation is sufficient for recursive improvement if and only if scaffolding is the binding constraint and the loop can persist, transfer, and compound. Weight-level mutation is sufficient if and only if weights are binding and the labs running training pipelines hand the integration decisions to the AI rather than retaining them. Neither sufficiency condition is currently met, and which one becomes binding first is the most important forecasting question.

A useful way to think about it: scaffolding can substitute for weights up to the point where the scaffold is exploiting all the capability latent in the model. Past that point, only model improvement helps. The empirical question is how much latent capability remains unscaffolded in current frontier models. If a lot, scaffold-RSI has substantial runway. If little, the next decisive moves are at the training layer, and scaffold-level demos are early-regime signals about a phase that will end.

A second consideration cuts the other way. The substrates are not equivalent even where they overlap. Weight-level successor training can alter the distribution of latent capabilities — what the model can do at all. Scaffold mutation mainly changes how a fixed model is invoked, searched, remembered, or tooled. Evidence for compounding at one substrate does not transfer cleanly to claims about compounding at another. A scaffold loop that demonstrably finds better scaffolds faster across generations would not, by itself, establish that a training loop could find better training procedures faster across generations. The substrates may both matter strategically while remaining empirically distinct.

7. What would change the evidence state

The evidence section can be summarized as: the components of recursive improvement are demonstrated in pieces, but no public system runs the full loop under conditions that distinguish meta-improvement from optimization. A clean way to change the evidence state is a preregistered multi-generation self-modifying agent benchmark with the following properties.

Fixed base model. All conditions use the same frozen model weights. This isolates the scaffold-mutation question from the confound of "did the model get better between runs."

Multiple substrates as conditions. A prompt-only arm; a scaffold-code arm; a scaffold-plus-evaluator arm under locked outer validation; a human-engineered baseline; a best-of-N non-recursive search baseline. The contrast between recursive and non-recursive search at equal cost is the most important comparison, because much of the apparent gain in scaffold systems is plausibly attributable to the search rather than the recursion.

Fresh held-out tasks per generation. Each generation is evaluated on tasks the system has not seen in any previous generation. This is the contamination control.

Meta-improvement as primary metric. The headline number is not the final score on the benchmark but the slope of the improvement curve: does the system find better modifications faster, cheaper, or in harder domains as generations progress?

Cost normalization. Improvements per dollar of compute and per minute of human intervention. A system that improves by spending more is not improving its loop; it is buying more search.

Autonomy curve. Human-intervention minutes per generation as a function of generation number. A loop that becomes more autonomous over time is qualitatively different from one that becomes more capable while remaining equally supervised.

Regression rate. Frequency at which integrated changes are later reverted. High regression rates indicate the integration mechanism is weak — the system cannot tell whether a change is actually an improvement, and the archive accumulates errors.

The strongest possible result would be a frozen-model system that shows multiple generations of transferable meta-improvement on fresh tasks with falling cost per gain and falling human-intervention rate. That result would not be classical intelligence explosion — the base model is still frozen, and the loop would still leave model-successor design to humans — but it would establish that scaffold-mediated recursive improvement is real, persistent, and accelerating, and it would shift the burden of proof on whether weight mutation is necessary.

The likely result is more ambiguous: gains that plateau after a few generations, transfer that holds within a domain family and breaks across families, autonomy that does not meaningfully decrease, and cost curves that look like extra search rather than improving search. That result is also informative: it would suggest scaffold-RSI is bounded in the way evaluation methodology people have suspected, and would push the live recursive frontier back toward training-loop and successor-model mechanisms — which are not public.

The relevant point is that the experiment has not been run. The evidence vacuum is not because the question is unanswerable; it is because no one has assembled the preregistered protocol, the fresh-task pipeline, and the willingness to publish a null result. Until someone does, claims about whether current systems "demonstrate RSI" are not empirical claims; they are interpretive ones.

8. RSI as an alignment-theory consideration

The alignment literature treats RSI as a forecasting and risk consideration rather than a present empirical phenomenon. The structural argument is unchanged from Yudkowsky and Bostrom: if some future system enters a regime of compounding capability growth, the time between "the system is roughly human-level at the relevant task" and "the system is far beyond human-level at the relevant task" can be short, possibly too short for external correction to operate. The argument does not depend on any particular present-day system being recursive; it depends on the conditional being live enough to plan for.

Anthropic's May 2026 Institute agenda explicitly treats AI-driven AI R&D and intelligence-explosion fire drills as core research topics for the next phase of capability (Anthropic Institute). This is the strongest recent institutional signal that a frontier lab considers the conditional live enough to invest in. It is governance-level evidence, not capability-level evidence. The lab is treating the pathway as plausible enough to warrant detection infrastructure; it is not claiming that the pathway is currently traversed.

The alignment-relevant question is therefore not "has RSI happened?" but "what would be the earliest unambiguous signals that it is starting?" Several candidate signals can be identified from the mechanism model in §3:

• Persistent cross-domain meta-improvement — a system whose ability to improve on domain B improves as a side effect of improving on domain A, without explicit transfer engineering.
• Falling human-intervention rate — a system that requires less per-generation supervision over successive runs.
• Improving evaluator — a system that modifies its own evaluation harness in ways that subsequent independent audits ratify as improvements rather than gaming.
• Closure on training — a system whose discovered improvements feed into the training of its own successor without explicit human integration decisions. (AlphaEvolve is the closest current case but the integration was human-mediated.)
• Self-bootstrapping tool acquisition — a system that acquires new external tools (APIs, environments, datasets) under its own initiative and integrates them into its scaffold.

The combination of those signals would be substantially more alarming than any individual one. Any one of them, in isolation, is consistent with bounded scaffold-level engineering of the kind §4 catalogs.

A second alignment-theory point worth naming: the "AI R&D automation" risk and the "classical RSI" risk are not the same risk. Anthropic's framing tracks both. AI-accelerated AI research can be safety-relevant without being recursive in the technical sense; it shortens the response window for everything else by speeding up the field, which compounds with capability overhang and with the gap between public and private systems. The strongest argument for taking RSI seriously in 2026 is not that any specific system is close to it but that the broader engineering substrate around frontier-model labs is becoming productive enough that the conditional in Good's argument is no longer purely speculative — it has identifiable components that can be tracked.

9. The honest summary

Recursive self-improvement is a coherent theoretical construct with a precise empirical referent: a system that improves the mechanism by which it produces future improvements, such that the rate, breadth, or autonomy of improvement compounds across generations. The classical literature established the construct as a forecasting and risk consideration; it did not establish that any system had demonstrated it.

As of May 2026, the public empirical record consists of:

1. Local self-optimization at fixed weights, mature and widely deployed (Self-Refine, Reflexion, Self-Debugging, Voyager).
2. Scaffold-level recursive modification in narrow domains under fixed evaluators, with persistent gains and limited transfer (Promptbreeder, STOP, ADAS, Darwin Gödel Machine, AlphaEvolve, capability-discovery pipelines).
3. Classical RSI with autonomous successor design, not publicly demonstrated.

The scaffold cluster is the live empirical frontier. It is bounded by the evaluator problem, the transfer problem, the autonomy problem, the contamination problem, and the bottleneck problem. None of those bounds is necessarily permanent; all of them are unaddressed by the strongest published systems. The question of whether scaffold-level mutation can substitute for weight-level mutation as a route to classical RSI cannot be resolved from current evidence — it depends on which capability bottleneck is binding for the next several years and on whether the closure conditions (persistence, transfer, autonomy, evaluator co-evolution) can be met without weight mutation.

The two failure modes for the discourse are symmetric. Treating scaffold-level demonstrations as evidence for classical RSI is evidence laundering; the demonstrations are real but the inferential bridge to intelligence explosion is not in them. Treating the gap between scaffold and classical as proof that RSI is irrelevant is overcorrection; the components are being assembled in pieces by labs that consider the conditional live enough to plan for. The intellectually honest stance is to track the conditions, name the disagreement where it falls naturally in the substrate question, and refuse to convert either the demonstrations or their limits into a stronger claim than the evidence supports.

Companion entries

Core theory: Intelligence Explosion · The Foom Debate · Bostrom's Optimization Power and Recalcitrance · Good's Closure Premise · Hard vs Soft Takeoff

Mechanism: Mutable Scaffolds · Evaluator Design in Self-Improving Systems · Persistence and Inheritance in Agent Loops · Meta-Improvement Rate · Capability Substrates: Weights, Scaffolds, Tools

Practice: Self-Refine and Reflexion Patterns · Prompt Optimization (Promptbreeder, DSPy) · Self-Debugging Coding Agents · Voyager-style Skill Libraries · Darwin Gödel Machine and Open-Ended Code Search · AlphaEvolve and Evaluator-Driven Algorithm Discovery · Capability Discovery and Integration Pipelines

Counterarguments and limits: Model Collapse and Recursive Training · Benchmark Contamination (SWE-bench-Live) · Evaluator Overfitting in Agent Loops · The Bottleneck Problem in Capability Growth · Cost-Normalized Improvement Curves

Alignment and forecasting: AI-Accelerated AI R&D · Capability Overhang and Public/Private Gaps · Detection Signals for Recursive Acceleration · Anthropic Institute Agenda on Intelligence Explosion Preparedness · Fire Drills for Capability Transitions

Adjacent infrastructure: Sandboxing for Self-Modifying Code · Audit Trails for Agent Code Modification · Multi-Model Agent Orchestration Patterns · Context-Window Economics