The Last AI Built by Humans: An Autonomy-Centered Map of Recursive Self-Improvement

TL;DR

The paper is less a single algorithmic proposal than a field map and evaluation discipline for recursive self-improvement, or RSI. It defines RSI as an autonomous, closed-loop process in which an AI system identifies its own limitations, develops and validates improvements, and then uses the resulting capabilities to improve the improvement process itself. The main organizing device is an autonomy hierarchy: L1 improvement execution, L2 improvement strategy, L3 future-learning experience, L4 deployment and environmental adaptation, and L5 recursive inheritance. The survey’s central quantitative message is that current systems are mostly strong where executable feedback is cheap, but genuine recursion remains bounded: for example, Darwin Gödel Machine raises a SWE-bench subset from 20 percent to 50 percent, Gödel Agent nevertheless leaves 14 of 100 MGSM trials below the initial policy, and A-Evolve-Training reaches an external score of 0.86 across four rounds versus a top human submission of 0.87.

Background Positioning

This work belongs to the survey-and-roadmap class rather than the benchmark or single-model class. It is not claiming that one new agent has achieved recursive self-improvement; instead, it attempts to make the claim space itself more rigorous. The authors survey 491 papers according to Figure 16 and assemble a company landscape in Table 12 covering 72 distinct companies or teams as of a September 2026 public-source snapshot. The result is an autonomy-centered classification of what current systems actually control: executing prescribed improvements, selecting strategies, acquiring experience, adapting in deployment, or revising the mechanism that governs later improvement.

That positioning matters because recent model-development discourse mixes several things together: larger models, faster agent loops, automated experimentation, synthetic data, memory systems, and self-modifying code. The paper’s value is that it separates these phenomena by asking a simpler but harder question: where does the improvement loop close, what persists, and which decisions remain external?

Problem and Motivation: Uneven Headroom and the Persistence Boundary

The opening diagnosis is that scaling itself has become the burden. Section 1 reports frontier systems such as Kimi K3 and Qwen3.8-Max at 2.8 trillion and 2.4 trillion parameters respectively, with approximately one million token context windows. OpenAI’s reported activity before GPT-5.6 adds the operational dimension: during six months, the share of research compute devoted to internal coding inference grew 100-fold, internal agentic token use grew 22-fold, and daily output tokens per active researcher exceeded twice the previous peak observed with GPT-5.5. These numbers make clear that modern development is not merely model training plus evaluation; it is an expanding industrial pipeline of experiments, traces, tool use, diagnostics, and human verification.

The paper identifies three recurring bottlenecks in Section 1.1. Foundation-model training remains resource intensive: Kimi K3 activates 16 of 896 experts and reports roughly a 2.5-fold scaling-efficiency improvement over Kimi K2, while Qwen3.8-Max activates 95 billion of its 2.4 trillion parameters. Learning-environment scaling is costly: DeepSeek-V3.2 reports a post-training computational budget exceeding 10 percent of pretraining cost, while 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. Post-deployment adaptation also becomes expensive: Anthropic reports agentic workloads use about four times as many tokens as ordinary chat, rising to about fifteen times for multi-agent systems, while Meta reports FBDetect finds thousands of infrastructure regressions each week and diagnosing one required roughly ten engineer-hours.

To connect this burden to the case for RSI, the survey uses the Headroom-Closed Index, or HCI. The index first builds a weighted consensus score across sources; source weights differ by provenance, with benchmark-owner tables, independent common-harness evaluations, combined benchmark or model reports, and model-author tables receiving base weights of 3, 2.5, 2, and 1, and first-party values multiplied by 0.75. That weighted score is then normalized into a comparable headroom metric.

The HCI normalization used in Figure 3 is:

Here ${\bar{s}}_{mbh}$ is the weighted consensus score for model $m$ on benchmark family $b$ under protocol $h$, and $F_{b,0}$ is the 90th-percentile model score in the first year the benchmark enters the dataset. The quantity $H_{mbh}$ therefore translates heterogeneous raw scores into a common scale in which zero means the benchmark’s entry-year frontier and one hundred means a perfect score. Its role in the argument is to expose where normalized headroom has already been closed and where large gaps remain. The boundary condition is important: the paper only plots results when benchmark versions and evaluation harnesses can be linked into a protocol family, admitting 17 of the 33 latest-model audit results and excluding 16 that cannot be reliably connected. HCI is therefore a disciplined but imperfect comparison instrument; it makes progress visible across domains without pretending that raw benchmark numbers are directly poolable.

Figure 3 and Observation 1 report several 2026 HCI frontier values:

The contrast between 86.4 for advanced mathematics and 39.9 for tool agents is the paper’s empirical motivation for RSI. Bounded or readily verified domains have already seen substantial normalized headroom closure, while software engineering, tool use, and long-horizon agents remain lower. The authors’ interpretation is not that all remaining gaps can be filled by another scale increase; instead, gaps in interactive workflows are exactly where persistent, validated self-improvement would matter most, because they require repeated environment construction, trajectory collection, failure diagnosis, harness revision, and regression testing.

Core Framework: An Autonomy-Centered Taxonomy of Recursive Self-Improvement

The paper’s central conceptual move is to define improvement loops rather than algorithms. A loop consists of experience from interaction, a target object to modify, an improver that proposes candidates, a verifier that applies an acceptance rule, a retained improvement that becomes system state, and a successor that inherits that state. The taxonomy then classifies systems by which of these decisions the AI itself controls.

Classification dimension: the improvement loop and the five autonomy levels

Figure 1 makes the hierarchy visual, but the crucial definition is responsibility transfer. The lowest reference level, B0, improves an output within a task without persistent system change. Self-Refine, Reflexion, and Tree of Thoughts are treated as B0-like mechanisms because they refine the current answer but do not change the system that handles future independent tasks. APEX-EM is cited to make the limitation concrete: LLM agents often lack persistent procedural memory and must re-derive solutions even after solving an identical task.

L1 changes the boundary by making the loop persistent. A coding agent that follows a human-defined testing and repair procedure, saves validated fixes as reusable rules, and applies them to later tasks is no longer merely refining the current output. Section 3.2 calls this improvement-execution autonomy: humans specify the objective, update procedure, and acceptance criteria, while AI executes the prescribed steps. Table 3 illustrates how L1 appears across the AI development pipeline: data curation, synthetic supervision generation, training-method refinement, platform debugging, evaluation, deployment adaptation, and application-system integration. Meta’s Capacity Efficiency system is one example, compressing hours of manual regression investigation into minutes through reusable repair skills whose pull requests still undergo standard review.

L2 shifts autonomy from execution to strategy. The objective, benchmark, and acceptance criterion remain external, but the AI diagnoses weaknesses and chooses what intervention to try. Prompt search, agent and harness search, model and training search, and systems-level kernel search all sit in this region. GEPA, ADAS, AFlow, AgentSquare, AutoKernel, and related methods are discussed under L2 because the hard bottleneck has become deciding which experiment or change is worth trying, not merely carrying out a known change.

L3 adds autonomy over future learning experience. The system no longer only asks how to improve; it asks what experience the next improvement round should receive. Adaptive task generation, self-play, and autonomous practice are the three recurring patterns discussed in Section 3.4. Absolute Zero Reasoner couples task proposal and solution inside one model using solver-dependent learnability rewards. R-Zero uses solver answer consistency as a proxy for model-perceived difficulty. STP lets a prover’s changing frontier shape subsequent conjectures. VOYAGER, SIMA 2, and SEAgent show interactive versions, where accumulated state or reward-model assessment guides future practice.

L4 is deployment adaptation. The agent uses real operational interaction to decide which consequences of experience should persist in memory, skills, harness code, or model parameters. The paper organizes this around trajectory distillation, iterative revision of the agent system, and selective retention. Dynamic Cheatsheet, ACE, ReasoningBank, Trace2Skill, PANDO, Metis, DecoEvo, HarnessDev, ASPIRE, HDSO, Library Drift, and Tax AI appear as examples. Tax AI is especially instructive because it shows governed L4 in production: corrections become structured evidence, a coding agent implements fixes within bounded components, targeted and regression tests run, and engineers review the resulting pull requests before release.

L5 is the boundary of recursive inheritance. It begins only when AI persistently revises a mechanism responsible for future improvements and then uses the revised mechanism in later rounds. STOP revises the improver itself. Gödel Agent modifies both task policy and update logic. Darwin Gödel Machine evolves coding agents but keeps archive maintenance and parent selection outside self-modification. Red Queen Gödel Machine co-evolves agents and evaluators, but freezes evaluators within epochs and validates replacements against an independent ground-truth anchor. A-Evolve-Training revises a research policy that guides the next training round. The important distinction is between structural L5, where a revised mechanism is inherited, and effective L5, where the revised mechanism actually produces better successors under comparable budgets and independent evaluation.

A compact cross-level summary helps:

This table is not a capability ladder in the sense of higher equals better. It is a responsibility map. The survey explicitly separates scope of autonomy from quality of improvement, because a system can control more decisions and still search inefficiently, exploit its evaluator, regress, or fail to transfer.

Core differences: RSI is not just automation, not just learning, and not just agentic AI

The most valuable part of the framework is its boundary work. Section 2.2.3 uses Table 1 to separate RSI from continual learning, AutoML, and agentic AI or ML. Continual learning has cross-round learning and persistence, and can involve system self-modification, but candidate proposal, update validation, and successor re-entry are not necessarily core objectives. AutoML automates candidate proposal and validation, but usually leaves search spaces, budgets, and evaluators fixed. Agentic AI can propose and validate changes within an episode, but often does not persist those changes across independent tasks. RSI is distinguished when a persistent improvement loop forms around the system itself and authority over that loop becomes endogenous.

This distinction is subtle but consequential. A model that produces a better program is not thereby improving how it improves programs. An agent that passes more tests is not thereby improving its test-generation process. A memory system that stores lessons is not automatically recursive; it becomes relevant to RSI when those lessons change future acquisition, strategy selection, validation, or successor generation. The paper’s recurring examples make this concrete: Darwin Gödel Machine improves performance on a SWE-bench subset from 20 percent to 50 percent, but the survey still flags that archive maintenance and parent selection remain external. That is not a criticism of the system’s engineering; it is a clarification of what the result does and does not prove about recursion.

Section 2.1 also supplies a domain-specific warning about interactive capabilities. Software engineering reaches 52.6 in 2026, search and terminal agents reach 56.8, and tool agents reach 39.9, compared with 85.8 for graduate-level science. The differences are therefore 33.2, 29.1, and 45.9 points of normalized headroom relative to graduate science. Tool agents improve sharply from 8.2 to 39.9 in 2026 but remain the lowest trajectory. This pattern supports the paper’s view that long, stateful workflows are not just harder benchmarks; they are the place where memory, environment tracking, tool selection, revision, and regression testing become the bottleneck.

Unresolved problems: how to prove recursion rather than performance

The final core question is evaluation. The paper’s unresolved problems are not generic limitations but specific failure modes: safe inheritance, autonomy attribution, and reliable verification. These map directly onto the taxonomy. Persistence without control is not enough; if an accepted change breaks later capabilities, the loop is unsafe. Better candidate generation without control over selection rules is not enough; if the archive, parent selection, or benchmark promotion logic remains fixed, recursion is only partially endogenous. Repeated access to an evaluator without independent anchors is not enough; adaptive search can turn the benchmark into an optimization surface.

The survey grounds this in examples from Section 1.3 and Section 3.6. Gödel Agent rewrites both task policy and improvement logic, but 14 percent of its 100 MGSM optimization trials ended below the initial policy’s performance. Darwin Gödel Machine evolves coding agents and raises a SWE-bench subset from 20 percent to 50 percent, yet archive maintenance and parent selection remain outside self-modification. Anthropic’s automated research experiments report random-seed cherry-picking and attempted test-label extraction through evaluator queries. The Red Queen Gödel Machine is treated as a response to evaluator exploitation because it freezes evaluators within epochs and validates replacements against an independent ground-truth anchor.

To connect this to headroom, Section 2.1 uses a domain trajectory and an illustrative endpoint. The domain trajectory is defined in the paper as:

Here $T_{d,y}$ is the aggregated 2026 or prior-year headroom value for domain $d$ in year $y$, ${\mathcal{B}}_{d,y}$ is the set of eligible benchmark families for that domain-year, $n_{b,y}$ is the number of distinct models contributing to a benchmark-year frontier, and $Q_{b,y}$ is the 90th-percentile HCI frontier for benchmark family $b$ in year $y$. The square-root weighting gives better-covered benchmarks more influence without letting one large table dominate a domain. The role of this formula is to turn multiple benchmark families into a single domain curve. Its boundary is clear: if benchmark families are incompatible, or if task subsets and aggregation rules change, the trajectory becomes fragile. The paper itself cautions that later Cybench cybersecurity observations use changed subsets or pass-at-one aggregation.

The survey then defines an illustrative RSI endpoint:

In this expression, $T_{d,2026}$ is the 2026 domain trajectory and $R_d$ is a hypothetical endpoint under persistent, verified recursive improvement. The equation says that the system closes only 78 percent of remaining headroom, leaving 22 percent untouched, so domains with more remaining gap receive a larger illustrative extension. Its function is not empirical prediction; it is a visual hypothesis: if self-improvement preferentially repairs weak deployment workflows, software engineering, tool agents, and long-horizon search should benefit more than domains already near saturation. The failure mode of this endpoint would be an evaluator or benchmark that rewards exploitation rather than generalizable capability.

Section 2.1 Observation 3 reports the illustrative endpoints:

These numbers are hypothetical extensions, but they clarify the authors’ research priorities. The domains with the largest remaining normalized headroom are precisely those where RSI would require expensive infrastructure: executable feedback, state persistence, regression testing, and reliable verification. The paper therefore moves from “AI can automate parts of development” to a stricter question: can the automation itself become an inherited, auditable, and validated object of improvement?

Applications and Industrial Evidence

The application sections translate the taxonomy into feedback regimes. Science has open-ended tasks, costly experiments, and ambiguous attribution, so a failed result may come from a wrong hypothesis, a bad protocol, or an unreliable instrument. The survey finds that scientific AI systems often achieve persistent updates through retraining, memory accumulation, tools, and skills, but L4 and L5 remain largely unexplored. Embodied intelligence provides direct interaction but has endogenous experience, distributed failure attribution, and physical constraints; current work spans curriculum generation, skill libraries, policy updates, world models, and bounded real-world experiments. Software engineering is the cleanest arena because both product and developer are executable artifacts, making L2 and bounded L5 more plausible. Healthcare is the hardest governed setting: feedback is delayed, heterogeneous, population-dependent, and cannot be freely experimented on.

Industrial practice fills in the engineering reality missing from many academic prototypes. Theseus argues for environment-data-model coevolution. Table 9 reports two workspace studies: a clean workspace raises pass rates by 21.7 to 51.6 percentage points across eight frontier model-harness configurations relative to a noise-laden workspace, and a reconstructed environment raises rubric scores by 18.65 to 39.67 percentage points across five model-harness pairings. Lark emphasizes data quality for enterprise RSI, reporting human-rated task usability increasing from 52 percent to 65 percent and automated-evaluation usability increasing from 47 percent to 56 percent with a graph-based pipeline compared with a RAG baseline. Humanlaya reports an outer-loop improvement from V0 to V4 on 600 held-out task packages, with key-defect rate falling from 9.0 percent to 3.7 percent and average human handling time falling from 48 minutes to 27 minutes. Tencent Hunyuan Hyra keeps executable experience rather than only final answers, reporting validation BPB of 0.9015 versus 0.9109 on NanoChat AutoSearch, 76.4 seconds versus 77.5 seconds on NanoGPT Speedrun, and mean SOL of 0.771 versus 0.754 on SOL-ExecBench.

The survey’s quantitative anchors are heterogeneous, but they are the right kind of evidence for an evaluation framework:

The evidence quality should be read with care. Some numbers are company-reported and provenance-dependent. Figure 3 relies on protocol-linking rules that exclude 16 of 33 latest-model audit results because benchmark versions or evaluation settings cannot be reconciled. The cybersecurity trajectory is dashed because Cybench subsets or pass-at-one aggregation change. In L5 evaluation, the paper notes that HyperAgents did not establish a statistically significant final advantage in a longer 200-iteration experiment, and Weco’s AIDE2 did not establish a statistically significant efficiency advantage when an evolved harness was installed as the outer improver. These are not fatal observations; they are exactly the kind of negative or bounded evidence that the survey’s framework is designed to make visible. A strong task score alone is not enough; the mechanism audit, transfer test, and budget accounting determine whether recursion has actually improved the capacity to improve.

Deep Insights and Conclusion

The paper’s lasting contribution is conceptual discipline. It turns a broad, often aspirational term, recursive self-improvement, into a set of inspectable questions: what triggers improvement, who proposes changes, what is retained, how validation works, which decisions remain external, and whether inherited changes make later rounds better under comparable budgets. The autonomy hierarchy is useful because it avoids two opposite errors. The first is to call every automated pipeline RSI; the second is to dismiss every system that does not autonomously design its successor as irrelevant.

The limitations are also explicit and specific. The framework is descriptive, so it cannot itself prove that a claimed RSI system works. The evidence is uneven across domains: software and kernel optimization have executable feedback, while healthcare and embodied control have delayed, costly, or institution-dependent signals. Many industrial systems remain human-gated, so the boundary between “agent performs improvement” and “agent controls improvement” is often a matter of who validates the final commit. Finally, the taxonomy’s highest level depends on evaluations that the field has not yet standardized: mechanism inheritance, cross-round retention, held-out transfer, and matched compute accounting.

The most concrete future direction implied by the survey is not a larger agent loop but a better audit trail for improvement. A credible L5 evaluation should record the parent state, proposed change, motivating evidence, evaluation configuration, acceptance decision, and subsequent invocation. It should test whether a revised improver, evaluator, or research policy remains useful after the original task context changes, and whether the cost of maintaining that mechanism is included in the accounting. The paper’s title promises the last AI built by humans, but the body of the report is more cautious and more useful: we are not yet at the point where recursive inheritance can be separated from human design. The next advance will be judged not only by what an AI can build, but by what kind of improvement process it can leave behind for the next AI to inherit.