The Last AI Built by Humans: Toward Genuine Recursive Self-Improvement

Abstract: Recursive self-improvement (RSI) enables AI systems to turn experience and feedback into persistent changes that improve both their capabilities and the process of future improvement. We first use the Headroom-Closed Index (HCI) to reveal the problems of existing LLMs, then introduce the RSI concept and its development roadmap: from improvement-execution autonomy, improvement-strategy autonomy, experience-acquisition autonomy, and environment-adaptation autonomy, to recursive meta-improvement. Next we examine RSI across scenarios (e.g., scientific discovery, embodied intelligence, software engineering), highlighting their distinct requirements and development speeds. Drawing on diverse industry practices and preliminary empirical evidence, we connect RSI research with practical systems and identify key challenges to achieving genuine RSI.

• The paper provides an autonomy-centered framework for analyzing AI self-improvement, defining five autonomy levels from output refinement to modifying improvement mechanisms
• The framework emphasizes the importance of comparing systems on their ability to persistently improve across improvement rounds, rather than just higher task performance through similar benchmark testing selections
• Industrial examples illustrate the practical challenges and successes of implementing recursive self-improvement, highlighting the importance of environmental adaptation and persistent state.

The paper presents an autonomy-centered framework for analyzing recursive self-improvement (RSI) in AI systems. Its central argument is that current discussions often conflate several distinct phenomena: iterative output refinement, persistent memory, automated experimentation, agent self-modification, and genuine improvement of the mechanism responsible for future improvement. The paper therefore treats the improvement loop—not the underlying learning algorithm or model architecture—as the primary unit of analysis. RSI is defined as a persistent, closed-loop process in which an AI system identifies limitations, proposes and validates modifications, retains accepted changes, and allows those changes to influence how subsequent improvements are generated, evaluated, selected, or consolidated (2609.11873).

The paper’s strongest conceptual claim is deliberately restrictive: higher task performance alone is insufficient evidence for RSI. A system must demonstrate persistence, attribution of autonomy, cross-round reuse, and—at the highest level—improvement of the improvement process itself. This distinction separates the paper from surveys that classify systems primarily by their capabilities, update targets, or degree of automation (Ren et al., 14 Jul 2026, Fang et al., 10 Aug 2025).

Motivation: the development pipeline is becoming the bottleneck

The paper begins from an empirical observation: frontier-model progress increasingly depends on a large, complex improvement pipeline involving data construction, post-training, evaluation, inference, infrastructure optimization, deployment, and human review. Model scale is only one component of this process. The paper cites models with trillions of parameters and approximately million-token context windows, alongside reports of rapidly increasing internal inference and coding-agent usage. The implication is that model development is no longer constrained solely by the ability to train a larger network; it is also constrained by the cost of coordinating the experiments and feedback required to improve that network.

Three burdens are emphasized. First, foundation-model training requires expensive data curation, architecture and systems design, distributed optimization, and evaluation. Second, scalable post-training requires task generation, synthetic supervision, reward construction, and reliable verification. Third, deployed agents require repeated diagnosis and adaptation as repositories, tools, documents, and workflows change.

The quantitative examples establish the scale of these burdens. The paper reports that GDPval’s 1,320 professional tasks required approximately 9,240 expert-hours, while Humanity’s Last Exam involved more than 70,000 submission attempts and approximately 13,000 questions sent for expert review before producing a 3,000-question benchmark. NVIDIA’s AIMO-2 pipeline generated 3.2 million long-reasoning solutions and 1.7 million tool-integrated solutions in addition to curating 540,000 problems. These figures support the paper’s claim that the marginal cost of generating candidate improvements can increasingly exceed the cost of executing them. RSI is consequently framed as an attempt to internalize the coordination and diagnosis required by the improvement pipeline.

The autonomy hierarchy

The paper proposes five RSI autonomy levels, preceded by B0, a non-RSI reference point. The levels are defined by the improvement responsibilities transferred from humans or fixed infrastructure to the AI system.

Figure 1: The five RSI autonomy levels, from executing prescribed updates to revising the mechanisms that govern subsequent improvement.

B0 covers in-task refinement. Systems such as Self-Refine, Reflexion, and Tree of Thoughts can generate, critique, and revise outputs, but the resulting changes are discarded when the task ends. B0 therefore improves an output without persistently improving the system that produces later outputs.

L1, improvement-execution autonomy, begins when accepted changes persist across tasks or improvement rounds. Humans still define the objective, procedure, and acceptance criteria; the AI executes the procedure and writes the result into persistent state. Examples include automated data filtering, prescribed debugging workflows, and deployment procedures. L1 is operationally important but conceptually limited: the system can execute a procedure only within the coverage of the procedure designed by humans.

L2, improvement-strategy autonomy, transfers responsibility for selecting interventions. The objective, task boundary, and evaluation criteria remain external, but the AI diagnoses weaknesses and determines how to improve the target. Prompt optimization, agent-harness search, architecture search, training-rule search, and GPU-kernel optimization are representative cases. GEPA, ADAS, AFlow, AgentSquare, AutoResearch, AgentNAS, and AutoKernel illustrate different realizations of this level (Zhang et al., 19 Mar 2026, Novikov et al., 16 Jun 2025, Jeong et al., 8 Jul 2026, Jaber et al., 22 Mar 2026).

L3, experience-acquisition autonomy, adds control over the future learning agenda. The system uses its current capabilities, failures, and interaction history to determine what experience to acquire next. This includes adaptive task generation, self-play, learner-conditioned curricula, and autonomous practice in interactive environments. The defining condition is not merely synthetic-data generation; it is a closed dependence between learner state, future experience acquisition, persistent learning, and later acquisition decisions.

Figure 2: L3 systems use learner state and interaction history to select or generate future learning experience, then feed persistent updates back into subsequent acquisition.

L4, deployment and environmental-adaptation autonomy, concerns persistent adaptation from operational interaction. The agent distills deployment trajectories into memories, skills, tools, harness changes, code modifications, or parameter updates and reuses them in later tasks. Humans retain the mission, deployment boundaries, protected evaluation, and release authority. PANDO, ReasoningBank, Metis, Trace2Skill, and related systems exemplify this pattern (Li et al., 24 May 2026, Dai et al., 23 Jun 2026, Ni et al., 26 Mar 2026).

L5, recursive-inheritance autonomy, is the paper’s strictest category. Here, the system modifies and inherits a mechanism that controls future improvement—for example, an improver, evaluator, research policy, successor-generation procedure, or search controller.

Figure 3: L4 adapts within a fixed improvement procedure, whereas L5 makes that procedure itself an inheritable object of improvement.

The paper distinguishes structural L5 from effective L5. Structural L5 requires evidence that a revised improvement mechanism persists and governs a subsequent round. Effective L5 additionally requires evidence that the revised mechanism produces better successors under comparable computational budgets and independent evaluation. This distinction is important because a self-modifying agent can alter its code without improving its capacity to generate future improvements.

RSI as a closed-loop system

The paper formalizes the improvement loop through several components: the AI system, persistent system state, experience, target, improver, strategy, verifier, improvement, and successor. This decomposition is intended to make autonomy claims auditable.

The target is the object directly changed in a round, such as a prompt, policy, harness, model, or code module. The improver converts state and experience into candidate modifications. The strategy determines how candidates are generated and where search is directed. The verifier evaluates candidates and applies the acceptance rule. The successor inherits accepted changes and re-enters the next round.

This decomposition yields three diagnostic questions:

1. Where does the loop close?
2. What is retained and inherited?
3. Which decisions remain external?

These questions prevent several common category errors. A model may generate a better external artifact without improving itself. A coding agent may modify its task policy while leaving parent selection fixed. A system may produce synthetic data automatically while leaving the learning agenda entirely human-designed. Conversely, a relatively modest memory or skill update may qualify as RSI if it persists, affects future behavior, and changes subsequent improvement decisions.

The paper’s loop-based analysis is related to work on self-evolving agents, continual learning, AutoML, agentic ML, and self-modifying programs, but it imposes a stronger requirement: the persistent state must influence later improvement, not merely later task execution (Ren et al., 14 Jul 2026, Li et al., 20 May 2026).

Uneven capability progress motivates RSI

To motivate where RSI may matter most, the paper introduces the Headroom-Closed Index (HCI), which normalizes heterogeneous benchmark results against an entry-year frontier and a perfect-score ceiling. The analysis covers 393 model–benchmark observations across ten domains.

The paper reports that advanced mathematics and graduate-level science reach HCI values of 86.4 and 85.8 by 2026, while broad knowledge reaches 77.2. Legal reasoning, multimodal reasoning, and frontier academic breadth remain lower at 64.5, 62.2, and 60.4. The most substantial gaps appear in interactive domains: software engineering reaches 52.6, search and terminal agents 56.8, and tool agents 39.9.

Figure 4: HCI trajectories show stronger progress in bounded domains than in long-horizon, stateful, and tool-mediated workflows.

The paper interprets this disparity as evidence that capability gains do not transfer uniformly from static or easily verifiable tasks to interactive workflows. Tool use, software engineering, and long-horizon agents require state tracking, planning, tool selection, result interpretation, and recovery from cascading errors. These properties correspond closely to the additional responsibilities introduced at L3 and L4.

The paper also projects illustrative post-2026 endpoints using a fixed headroom-closure rule. Under that illustrative—not empirical—extension, software engineering rises from 52.6 to 89.6, search and terminal agents from 56.8 to 90.5, and tool agents from 39.9 to 86.8. These values should not be read as forecasts. They express the paper’s hypothesis that persistent experience acquisition, verification, and adaptation may disproportionately benefit domains with large remaining headroom.

The HCI analysis has a methodological limitation: benchmark families differ in protocol, coverage, and evaluation reliability. The paper excludes incompatible benchmark versions from plotted trajectories and explicitly notes that later cybersecurity observations involve changed subsets or pass@1 aggregation. Thus, the trajectories are useful for identifying broad asymmetries, but they do not establish that RSI itself caused any subsequent improvement.

L2: selecting how to improve

L2 is the most mature part of the proposed hierarchy. It includes systems that transform evaluation evidence into candidate interventions while retaining external objectives and acceptance rules.

Prompt optimizers such as GEPA use execution traces and failure attribution to generate targeted prompt changes. Agent-design systems such as ADAS and AFlow search over executable agent programs or workflows. AgentSquare searches over modular agent structures. Training-oriented systems automate configuration search, architecture construction, training-rule modification, and implementation optimization.

AutoKernel illustrates the favorable conditions under which L2 is currently effective: the target is executable, correctness can be tested, hardware performance can be measured, and unsuccessful candidates can be rolled back. The same pattern appears in automated training experiments, where a fixed validation metric allows the system to iterate rapidly over code and configuration changes.

The paper’s interpretation is deliberately bounded. L2 systems automate the selection of interventions, not the definition of success. An agent may discover a superior workflow while remaining unable to determine whether the benchmark is incomplete, whether the objective is misaligned with external performance, or whether the evaluator is exploitable. Repeated adaptive access to a development evaluator can also produce benchmark overfitting, seed selection, test-label extraction, or reward hacking. Accordingly, L2 evaluation must report evaluator access, search compute, protected test performance, and the provenance of acceptance decisions.

L3: autonomous acquisition of learning experience

The paper treats L3 as qualitatively different from ordinary synthetic-data pipelines. Operational automation—filtering, labeling, generation, and orchestration—does not establish that the system controls its future learning agenda. The decisive evidence is that learner feedback changes what experience is selected or generated next and that persistent learning changes later acquisition decisions.

Adaptive task-generation systems provide one route. Search Self-Play makes proposer rewards depend on solver performance. Absolute Zero uses solver-dependent learnability rewards and executable verification to generate reasoning tasks without human task labels (Team et al., 4 Dec 2025). R-Zero uses solver consistency as a difficulty proxy, although the paper notes that consistency measures perceived uncertainty rather than correctness or learning value. STP and PSV use formal proof or execution checks, but formal validity remains conditional on the specified task and does not guarantee that the task is pedagogically useful.

Interactive agents provide a second route. Voyager uses exploration history and a persistent skill library to guide Minecraft objectives (Wang et al., 2023). SIMA 2’s full ASKA configuration uses reward-model feedback to direct practice toward weaker skills. SEAgent maintains a persistent software guidebook that shapes future task generation.

Figure 5: Training-data pipelines already automate many operations, but operational automation is distinct from learner-conditioned experience autonomy.

The paper’s key qualification is that L3 autonomy does not guarantee useful learning. Experience can be valid but uninformative, difficult but incorrect, or correctly evaluated but irrelevant to generalization. Evaluations must therefore distinguish correctness, difficulty, and marginal learning benefit. They should also compare adaptive acquisition against learner-independent schedules under matched data-source access and total compute.

L4: deployment adaptation and persistent state

L4 extends adaptation into changing environments. The central issue is not only what the agent learns, but which consequences of deployment experience become persistent state.

The paper organizes L4 methods into trajectory distillation, iterative system revision, and selective retention. Textual-memory methods such as Dynamic Cheatsheet, ACE, and ReasoningBank preserve strategies and lessons in natural language. Structured-memory systems such as APEX encode dependencies and outcomes in graphs. Skill systems such as Trace2Skill and PRACTICE convert trajectories into reusable procedures. Metis compiles repeatedly useful plans into executable tools after sandbox validation. Harness-oriented systems update context selection, tool use, control logic, or other execution infrastructure.

The paper emphasizes that persistent retention is not equivalent to reliable improvement. A useful artifact can fail because it is never retrieved, because it is retrieved but not followed, because it is applied outside its validity conditions, or because it causes regressions elsewhere. The Library Drift analysis demonstrates that unbounded skill accumulation can degrade retrieval quality and stall progress. This implies that L4 requires lifecycle management—admission, versioning, revalidation, merging, retirement, and rollback—not merely a larger memory store.

Production-oriented cases make the governance boundary explicit. In the Tax AI example, practitioner corrections produce structured evidence; an agent modifies bounded parts of the product; targeted and regression tests are applied; and engineers review the resulting change before release. This is a meaningful deployment-adaptation loop, but it remains human-gated.

L5: improving the improvement mechanism

The paper identifies several forms of L5-like behavior.

STOP recursively improves a program that generates and evaluates candidate programs. The selected improver is reused in the next round, making the search procedure itself the inherited object. The paper reports that a fourth-generation improver outperformed the seed on all five transfer tasks excluded from self-improvement, while weaker-model settings regressed on average and some generated programs exploited soft budgets or evaluation bugs (Zelikman et al., 2023).

G\"odel Agent modifies both its task policy and recursive update logic. However, 14 of 100 MGSM optimization trials ended below the initial policy’s performance. This result is important because it demonstrates that self-modification can be persistent and recursive while remaining unstable.

The Darwin G\"odel Machine improved a SWE-bench subset from 20% to 50%, but its archive maintenance and parent-selection rules remained external. The paper therefore treats it as a transition case rather than unqualified L5 evidence (Zhang et al., 19 Mar 2026).

The Red Queen G\"odel Machine co-evolves agents and evaluators while freezing the evaluator within each epoch and validating replacements against an independent anchor. It reports a 71.7% pass rate on held-out Polyglot coding tasks compared with 69.9% for HGM-H, together with lower search-token use (Iacob et al., 24 Jun 2026). The result supports bounded evaluator evolution, but the anchor, epoch schedule, and replacement policy remain external.

A-Evolve-Training provides the clearest research-policy example. Across four autonomous rounds on a 30B Nemotron model, the external score reportedly increased from 0.80 to 0.86, compared with 0.87 for the best human submission (Shi et al., 9 Jun 2026). The system retained a research policy and discovery log, and revised its search direction when development scores improved without corresponding external gains. The implication is substantive: a research agent can modify not only a model or training recipe, but also the policy governing which experiments are attempted next. Yet the constitution, objective, worker substrate, and benchmark remained fixed.

Figure 6: Hyra retains executable solutions, traces, scores, and evaluator feedback so that later proposals can reuse prior experience and refine evaluation when needed.

Tencent Hunyuan Hyra reports improvements on three AI-for-AI benchmarks: nanochat validation BPB from 0.9109 to 0.9015, nanoGPT Speedrun time from 77.5 seconds to 76.4 seconds, and SOL-ExecBench from 0.754 to 0.771. These results show the value of retaining executable experience rather than only textual summaries. They do not, by themselves, establish multi-generation improvement of Hyra’s own search mechanism under matched budgets.

Application regimes

The paper argues that RSI cannot be evaluated independently of the feedback regime of the application.

Figure 7: Application domains differ primarily in the evidence required to validate and inherit an improvement.

In scientific discovery, feedback is sparse, delayed, and difficult to attribute. A failed experiment may reflect a hypothesis, protocol, instrument, or analysis error. Current systems such as HypoForge, DrugSAGE, SIA, and CORAL demonstrate persistent skills, experience banks, and adaptive research workflows, but the paper finds little evidence for end-to-end L4 or L5 scientific RSI across real experimental settings (Qian et al., 26 Aug 2026, Zhang et al., 14 May 2026, Hebbar et al., 26 May 2026, Qu et al., 2 Apr 2026).

In embodied intelligence, experience is endogenous to the current policy, failures are distributed across perception, planning, control, and hardware, and physical trials are costly and difficult to reset. POET, EnvGen, GenEnv, Voyager, SHAPER, ASPIRE, and ENPIRE cover environment generation, skill evolution, policy improvement, and harness revision (Wang et al., 2019, Zala et al., 2024, Guo et al., 22 Dec 2025, Lu et al., 30 Jun 2026, Xiao et al., 18 Jun 2026). The paper’s conclusion is that these capabilities remain largely modular: safe, persistent, real-world recursive improvement across embodiments has not been demonstrated.

Software engineering offers the most favorable feedback regime because both the product and the agent are executable. Repository tests, traces, code review, sandbox execution, and version control provide relatively cheap and reversible feedback. DGM reports an increase from 20% to 50% on its SWE-bench subset, while systems such as Self-Harness, Ouroboros, SWE-Exp, CODESKILL, and DarwinX target persistent agent or harness improvement (Zhang et al., 8 Jun 2026, Razzhigaev et al., 8 Aug 2026, Chen et al., 31 Jul 2025, Li et al., 25 May 2026, Zhang et al., 31 Jul 2026). Even here, the paper notes that test coverage, specification quality, benchmark leakage, and human review remain external constraints.

Healthcare is the most restrictive regime. Feedback is delayed, heterogeneous, confounded, and safety-critical. Existing systems evolve clinical memories, diagnostic strategies, tools, and workflows, but most evidence comes from simulation, retrospective cases, or externally supplied labels. Real longitudinal L4 adaptation and L5 evolution of the clinical improvement mechanism remain largely unexplored (Li et al., 2024, Ren et al., 11 Mar 2026, Shen et al., 15 Apr 2026, He et al., 30 Jan 2026).

Industrial evidence and preliminary systems

The industrial section broadens the evidence base beyond conventional academic papers to include technical reports, engineering blogs, repositories, and product documentation. The paper is explicit that such evidence demonstrates operational mechanisms and feasibility, but often lacks independent replication, matched budgets, or complete disclosure of human intervention.

Theseus proposes a four-stage environment–data–model co-evolution loop: reconstruct environments, identify capability gaps, generate training data, and retrain task models. In a pilot involving eight model–harness configurations on 30 workspace tasks and 1,280 rubrics, clean workspaces improved pass rates over noisy workspaces by 21.7–51.6 percentage points. In a follow-up study, reconstructed environments improved rubric scores by 18.65–39.67 percentage points across five fixed model–harness pairings. These results suggest that environment state can impose a large performance bottleneck independent of the underlying model. They do not yet establish that the full environment-refinement and task-model loop compounds across multiple training generations.

Figure 8: Theseus couples environment reconstruction, capability-gap discovery, data generation, and model training in a proposed co-evolution loop.

Humanlaya reports a more directly measured scaffold-level loop. After four feedback-driven updates, its V0-to-V4 comparison on 600 held-out task packages reduced the rate of packages containing key defects from 9.0% to 3.7% and reduced average human handling time from 48 to 27 minutes per task. The same base model, tools, and processing budget were used. This is one of the paper’s stronger industrial results because it measures both quality and human workload. However, human review and final approval remain part of the process; the result demonstrates governed RSI rather than unconstrained autonomy.

ModelBest’s Forge Engineering reports that ForgeTrain generated a pre-training framework from an empty directory that matched Megatron-LM v0.15 on H100 in approximately eight hours and reportedly surpassed it within 1.5–2.5 days. The reported manual comparison is three to five engineers working for six to twelve months. FLOPs utilization increased from 40.1% to 44.1% for a 0.5B model and from 47.0% to 50.9% for an 8B model. ForgeStencil reports 1.15–1.9x speedups over public baselines, with a median end-to-end speedup of 1.41x. These are substantial engineering results, but the comparisons are company-reported and should not be interpreted as controlled evidence of recursive improvement without independent reproduction and complete accounting of infrastructure and verification costs.

Agent-Native Research Lab emphasizes the inheritance substrate rather than only the search agent. Its Agent-Native Research Artifact preserves code, formal specifications, raw evidence, successful and failed branches, and executable claims. The reported results are 93.7% question-answering accuracy over prior work compared with 72.4% using conventional papers, and RE-Bench reproduction success of 64.4% compared with 57.4%. In a silicon-design setting, the system reports a Chip-Bench Level-3 score of 5.8416, with a design 2.7% faster and 21.5% smaller than a standard-agent baseline while passing 97 directed tests and 350 random differential programs. These results support the paper’s argument that verifiable, richly structured inheritance is an infrastructure requirement for RSI. They do not yet establish matched-budget compounding over multiple generations.

Figure 9: Agent-Native Research Lab combines executable artifacts, deterministic verification, exploration history, and inherited research state.

Limitations and open questions

The paper is a broad survey and framework rather than a single controlled empirical study. Its evidence combines peer-reviewed work, preprints, technical reports, industrial disclosures, blogs, repositories, and preliminary internal results. These sources differ substantially in reproducibility, evaluation protocol, reporting completeness, and independence. The paper appropriately labels many industrial results as preliminary, but the heterogeneity limits direct quantitative comparison.

The HCI analysis depends on benchmark-family linking, weighted source consensus, and normalization against entry-year frontiers. These design choices improve comparability but do not eliminate benchmark drift, changing harnesses, or selective reporting. Several plotted domains include protocol changes, and the illustrative RSI extensions are explicitly hypothetical.

More fundamentally, the five-level hierarchy classifies responsibility rather than performance. A system may satisfy an L3 or L4 structural criterion while producing poor, unstable, or non-transferable updates. Conversely, a highly effective automated pipeline may remain L1 or L2 because its objectives and update procedures are fixed externally. The paper leaves open how autonomy should be quantified when responsibility is distributed across agents, evaluators, human reviewers, and fixed infrastructure.

The principal unresolved empirical question is effective L5. Existing systems show that improvers, evaluators, research policies, or harnesses can be modified and reused, but statistically reliable accumulation of improvement capacity across generations under matched resources remains unestablished. The paper also leaves open how to maintain evaluator independence under adaptive access, how to attribute gains across jointly evolving components, how to detect harmful persistent state, and how to calculate the total cost of verification, infrastructure maintenance, human review, rollback, and rework.

Conclusion

The paper’s main contribution is a responsibility-based taxonomy of RSI organized around the improvement loop. B0 concerns transient output refinement; L1 executes prescribed updates; L2 selects interventions; L3 selects future learning experience; L4 adapts persistently from deployment; and L5 improves the mechanism governing subsequent improvement. The taxonomy clarifies why persistent memory, automated experimentation, self-modifying code, and stronger benchmark performance are not interchangeable forms of RSI.

The surveyed evidence supports substantial progress through L2, emerging L3 and L4 mechanisms, and bounded structural forms of L5. The strongest unresolved issue is not whether AI systems can generate better artifacts, but whether inherited changes can reliably improve the process that generates, verifies, and inherits later improvements under independent evaluation, explicit resource accounting, and retained human control over consequential objectives and releases.