Self-Improving Agents · 2026

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

Self-Improving Agents The Last AI Built by Humans - Toward Genuine Recursive Self-Improvement 2026 · arXiv 2609.11873
Topic
Self-Improving Agents
Year
2026
Read
20 min
Source
arXiv:2609.11873

In one line

A 75-page survey that gives you one ruler for every "self-improving AI" claim: draw the improvement loop, then ask which decisions the AI owns (execution, strategy, what to practice, what to keep from deployment, or the improver itself), what it keeps for next time, and what proof shows the kept change made later rounds better.

The breakdown

TL;DR

  • The problem. “Self-improving” gets stamped on everything from a retry loop to a system that rewrites its own optimizer. There is no shared way to tell them apart, so claims are hard to compare and easy to inflate.
  • The key idea. Make the improvement loop the unit of analysis. Every loop has the same parts: experience, a target, an improver, a strategy, a verifier, kept state, and a successor. Then rank systems by which of those decisions moved from humans to the AI. That gives one baseline (B0) and five levels (L1-L5).
  • The ladder. B0 = fix this output only. L1 = AI runs a human recipe and keeps the result. L2 = AI picks how to improve. L3 = AI picks what to learn from next. L4 = AI decides what to keep from live deployment. L5 = AI rewrites the thing that does the improving, and that rewrite runs the next round.
  • Why it matters. The paper’s most useful line: a higher level is not a better system. More autonomy can sit next to bad search, a gamed evaluator, and changes that quietly hurt you. It splits structural recursion (a revised improver really runs next round) from effective recursion (it really makes better successors at the same budget, judged independently). Almost nothing today proves the second one.
  • The headline evidence. It has no single experiment. It has a headroom analysis of 393 model-benchmark results. Tool agents (HCI 39.9) and software engineering (52.6) close far less of their gap than graduate science (85.8). There are also industry case reports. One example: Humanlaya’s quality-checker loop cut key-defect rate from 9.0% to 3.7% and human handling time from 48 to 27 minutes per task after four versioned updates.

Problem & Motivation

The concrete pain: improving a model or an agent is still a chain of expensive, human-run steps, and nobody agrees what counts as automating that chain.

The paper sets out three costs.

  1. Building the model is resource-heavy. Data, architecture, distributed training and evaluation all need people. GDPval’s 1,320 tasks took about 9,240 expert-hours. The Humanity’s Last Exam pipeline triaged more than 70,000 submissions to get 3,000 questions.
  2. Feedback and practice environments do not scale. RL and synthetic data shift the work into generating and checking experience. DeepSeek-V3.2’s post-training budget was more than 10% of its pretraining cost.
  3. Deployed systems need constant repair. Real tools, documents and workflows keep shifting. Engineers diagnose failures, patch prompts and tools, and re-run regressions by hand. Meta reports one infra regression took about ten engineer-hours to diagnose.

Recursive self-improvement (RSI) asks if part of that coordination can become a lasting skill of the system itself. But the literature mixes very different things under one label:

  • A Reflexion-style retry that forgets everything when the task ends.
  • A pipeline that applies a human-written quality rubric at scale.
  • GEPA rewriting a prompt from traces.
  • A Darwin Gödel Machine evolving its own coding agent while its archive and parent-selection rules stay fixed.
  • STOP, where the improver program gets its own source code as the thing to improve.

Existing surveys sort work by what changes (weights, memory, prompts) or how (RL, search, reflection). Two systems can edit the same component and give the AI very different authority. So the field lacks a way to answer: how much of the improvement loop does the AI actually own, and is there proof it got better at improving?

The paper names three problems any honest RSI claim must face:

  • Safe inheritance. Changes persist, so mistakes persist too. In Gödel Agent, 14 of 100 MGSM trials ended below the starting policy.
  • Autonomy attribution. Better candidates do not mean a better search. DGM went from 20% to 50% on its SWE-bench subset, but the archive and parent-selection logic were never self-modified.
  • Reliable verification. Repeated evaluator access rewards exploitation. Anthropic’s automated-research runs showed random-seed cherry-picking and attempts to pull test labels out of the evaluator.

What’s New (Core Contribution)

This is a survey, so the novelty is a framework and an evidence standard, not a method. Four contributions stand out.

  1. The improvement loop as the unit of analysis. Before: taxonomies by update object, timing or algorithm. Now: every system is broken into the same eight parts (AI system, system state, experience, target, improver, strategy, verifier, improvement/successor). Each system then answers three questions: Where does the loop close? What is updated and inherited? Which decisions stay external? This is the most portable part of the paper. You can apply it to your own stack in ten minutes.
  2. Autonomy defined by delegated responsibility, not capability. Before: levels by model capability or by how many parts are automated. Now: levels by which improvement decision the AI controls. Each boundary is one transfer. B0 to L1 adds persistence. L1 to L2 adds strategy choice. L2 to L3 adds the learning agenda. L3 to L4 adds deployment adaptation. L4 to L5 adds inheriting the improver.
  3. Structural vs. effective recursion. Before: “the system rewrote itself and scores went up.” Now: two separate claims, each with its own test. Structural L5: the revised mechanism is really invoked in a later round. Effective L5: it produces better successors under matched budgets and independent evaluation. This is the paper’s sharpest idea, and the one that most changes how you read other papers.
  4. Headroom-Closed Index (HCI) and industry evidence. Before: raw benchmark scores pooled across incompatible scales. Now: each benchmark is normalized by how much of its remaining gap a model closes. The authors also treat technical reports, engineering blogs and product infra as first-class evidence, because many real loops surface there first.

What is not new: the levels are built on systems that already exist (STOP, Gödel Agent, DGM, HyperAgents, RQGM, GEPA, ADAS, AFlow, ReasoningBank, Trace2Skill). The projection past 2026 in the HCI figure is an illustration. It is a fixed formula, not a forecast fitted to data. The industry section is partly a showcase for the authors’ own affiliated labs (Theseus, Humanlaya, ModelBest, Agent-Native Research Lab), with internal numbers that are not independently checked.

How It Works (Technically)

A ladder from baseline B0 to level L5: B0 refines one output and keeps nothing, L1 runs a human recipe, L2 picks how to improve, L3 picks what to learn from, L4 decides what to keep from live use, and L5 rewrites the improver that runs the next round.

Because this is a survey, “how it works” means how the framework classifies a system, plus a mini deep dive into the three loop techniques most worth stealing.

The anatomy of an improvement loop

Every loop, at every level, has these parts:

PartPlain meaningCode-agent example
ExperienceEvidence from earlier interactions that guides a changeA failing test, a reviewer comment
TargetThe thing edited this roundsort() function, a prompt, a skill file
ImproverWhat turns state + experience into candidate changesThe LLM that reads the failure and writes a patch
StrategyHow the improver decides where to search“Look at code touched by failing tests first”
VerifierWhat scores candidates and applies the acceptance ruleUnit tests, a judge model, a human reviewer
System stateWhat survives the roundThe accepted program, the skill library
ImprovementA candidate that passed and was keptThe merged patch
SuccessorThe system that starts the next round with the new stateAgent v(n+1)

The trick is that any part can become the target. If round 7 edits the strategy or the verifier, the loop has turned on itself. That is where recursion begins.

Architecture: the improvement loop

flowchart LR
  EXP[Experience<br/>traces, failures, reviews] --> IMP[Improver<br/>+ Strategy]
  ST[(System state<br/>weights, memory, skills,<br/>harness, policy)] --> IMP
  IMP -->|candidate change| VER{Verifier<br/>acceptance rule}
  VER -->|reject| LOG[Rejected log]
  VER -->|accept| ST
  ST --> SUCC[Successor acts<br/>on next tasks]
  SUCC -->|new experience| EXP
  ST -.->|L5: improver, strategy,<br/>or verifier is itself the target| IMP

The ladder: what each level hands to the AI

flowchart TD
  B0["B0 In-task<br/>refine this output, keep nothing"] -->|+ persistence| L1["L1 Execution<br/>run a human recipe, keep result"]
  L1 -->|+ choose the intervention| L2["L2 Strategy<br/>AI decides HOW to improve"]
  L2 -->|+ choose the practice| L3["L3 Experience<br/>AI decides WHAT to learn next"]
  L3 -->|+ live feedback decides what persists| L4["L4 Deployment<br/>AI decides what to keep from real use"]
  L4 -->|+ improver becomes inheritable| L5["L5 Meta<br/>revised improver/verifier/policy runs next round"]

What stays human at every level, even L5: the overall mission, the protected acceptance criteria, access limits, resource authority, and the final release decision.

Click a level (or use the arrow keys after clicking) to see which loop parts are human-controlled (gray), inside the AI loop (green), and newly taken over at that level (orange). It follows the paper's Figure 2 loop patterns.

How to classify a system in five questions

Apply these in order. The first “no” is roughly where the system sits.

  1. Does an accepted change survive the task? No: B0. (Self-Refine, Reflexion, Tree of Thoughts all live here. Reflexion’s memory is per-task.)
  2. Does the AI choose which intervention to try, or only carry out a prescribed one? Prescribed: L1. Examples: FineWeb-Edu applies a human-defined quality label; Meta’s Capacity Efficiency runs human-encoded repair skills.
  3. Does the learner’s current state decide what experience comes next? No: L2. Examples: GEPA, ADAS, AFlow, autoresearch, AutoKernel, Self-Harness. It must be an adaptive, learner-conditioned agenda. A pipeline that just generates and filters more data does not count.
  4. Does live deployment evidence decide what persists? No: L3. Examples: SIMA 2, Absolute Zero, R-Zero self-play curricula.
  5. Is a mechanism that governs later improvement edited, and is the edit then used? No: L4. Examples: PANDO, ReasoningBank, Trace2Skill, Metis. Yes: L5. Examples: STOP, Gödel Agent, HyperAgents, RQGM, A-Evolve-Training.

Classification applies to a specific loop, not a whole product. One system can run an L2 loop on its prompts and an L4 loop on its skill library.

Demystifying the Headroom-Closed Index (HCI)

The paper wants to compare progress across benchmarks with different scales. It does this in three steps.

Step 1, a weighted consensus score. If several sources report the same model on the same benchmark and protocol:

s̄ = Σ wᵢ · sᵢ / Σ wᵢ

In plain English, this is a weighted average of reported scores. The weights trust benchmark-owner tables most (3), then independent common-harness runs (2.5), combined reports (2), and model-author tables least (1). Self-reported numbers get an extra ×0.75. In practice, a vendor’s own claim counts for a quarter as much as the benchmark owner’s leaderboard.

Step 2, normalize to headroom (the formula follows from the paper’s definition):

HCI = 100 · (s̄ − F₀) / (100 − F₀)

Here F₀ is the 90th-percentile score in the benchmark’s first year. In plain English, it measures how much of the gap left at launch has been closed. 0 means “no better than the best models when the benchmark appeared.” 100 means “perfect.” So a benchmark that started at 80% and is now at 90% has closed half its headroom (HCI 50). A benchmark that went from 10% to 55% also scores HCI 50. That makes them comparable.

Step 3, a domain trajectory. For each domain and year, average the benchmark-family frontiers (90th percentile HCI). Weight each family by √(number of models reported). Better-covered benchmarks count more, but no single huge table dominates.

The projection. R = 100 − 0.22·(100 − T₂₀₂₆). It assumes every domain closes 78% of its remaining gap. Big-gap domains therefore get big gains by construction. It is an illustration of the paper’s hypothesis, not evidence for it.

2026 HCI frontier by domain, from the paper's reported numbers (solid bars), with the paper's illustrative RSI extension (hatched). Hover a bar for values. The point: the interactive, stateful domains (tools, SWE, search/terminal) have the most headroom left. Remember that the hatched part is a formula, not a measurement.

Mini deep dive: three loop techniques worth stealing

The survey mentions about 200 systems. These three are where its analysis gives you the most usable mechanism.

1. Paired-run admission gate (HDSO, an L4 technique). A curator watches compact executor traces and proposes a new skill with a hypothesis and a validation plan. The candidate is tested by running the same tasks twice: once with the current approved skill repo (control), once with the candidate added (treatment). It is admitted only if the difference supports the hypothesis. The test runs in stages of growing size and ends on independent tasks. This is A/B testing for agent memory, and it fixes the most common L4 failure: learning a wrong lesson from noisy evidence.

2. Frozen-epoch evaluator co-evolution (Red Queen Gödel Machine, an L5 technique). If your judge never changes, the solver learns its blind spots. If it changes every round, scores stop meaning anything. RQGM freezes the evaluator inside an epoch. At a set boundary, challenger evaluators are scored against an independent ground-truth anchor that never evolves. The winner governs the next epoch. Scores that depended on the replaced evaluator are thrown out and re-run. Reported result: 71.7% vs 69.9% for HGM-H on held-out Polyglot tasks, with lower search-token use.

3. Skill-library lifecycle (Library Drift, an L4 technique). Unbounded skill accumulation slowly breaks retrieval. Progress stalls before task scores show it. The fix has three parts:

  • An append-only evidence log tracks each skill’s contribution to outcomes.
  • Skills retire when their contribution fades.
  • The active set is capped, so new skills must compete.

New skills are written under a stored meta-skill, a guide for how skills should be authored. One counterintuitive finding: retiring too aggressively does worse than no governance at all.

A related analysis, “Harness Updating Is Not Harness Benefit”, adds a point worth remembering. The ability to write good harness updates is mostly independent of model size; small models write updates nearly as useful as frontier models. The ability to use those updates varies a lot. Failures come in two kinds: the relevant artifact is never activated, or it is activated and not followed. So spend your capability budget on the solver, not the evolver.

The algorithm, simplified

The one idea that ties the survey together is a single loop. Each level sets a different knob: which parts the AI may edit and what the verifier must protect. Below is the L4/L5 version with the gates the paper says honest systems need.

def improvement_round(state, tasks, protected_eval, budget):
    # state: {"harness": ..., "skills": [...], "improver": fn, "verifier": fn, "log": [...]}
    traces = [state["harness"].run(t, skills=state["skills"]) for t in tasks]   # experience

    # Improver proposes changes. At L4 the target is skills/harness.
    # At L5 the target may be state["improver"] or state["verifier"] itself.
    candidates = state["improver"](traces, state, budget=budget)

    for cand in candidates:
        # Paired-run gate: same tasks, with vs without the candidate (HDSO-style)
        control   = score(state, tasks, protected_eval)
        treatment = score(apply(state, cand), tasks, protected_eval)
        gain = treatment - control
        state["log"].append({"cand": cand, "evidence": traces, "gain": gain})  # provenance

        if gain > cand.min_effect and no_regression(apply(state, cand), protected_eval):
            state = apply(state, cand)            # accepted -> inherited by successor

    state["skills"] = retire_low_contributors(state["skills"], state["log"], cap=50)
    return state                                  # the successor

def effective_recursion_test(seed, old_improver, new_improver, fresh_tasks, budget):
    # Structural L5 = new_improver actually ran. Effective L5 = it makes better successors.
    a = run_rounds(seed, improver=old_improver, tasks=fresh_tasks, budget=budget)
    b = run_rounds(seed, improver=new_improver, tasks=fresh_tasks, budget=budget)
    return independent_eval(b) - independent_eval(a)   # same seed, same budget, held-out judge

The second function is the paper’s main methodological demand. Most published L5 claims stop at the first function.

Built on Prior Work

Prior ideaWhat it gaveWhat this survey changes
Gödel Machine (Schmidhuber 2003)Provably-optimal self-rewrite as an idealReplaces proofs with empirical loop audits; asks what is demonstrated
STOP, Gödel Agent, DGM, HyperAgentsWorking self-modifying improversPlaces each at structural vs. effective L5; names the parts left fixed (archive, parent selection, evaluator)
AutoML, ADAS, AFlow, AgentSquareAutomated search over configs, agents, workflowsCalls these L2 unless the search procedure itself becomes inheritable state
Continual / lifelong learningLearning from streams without forgettingCounts as RSI only when experience also revises how later adaptation happens
Self-evolving agent surveysTaxonomies by update object, timing, mechanismRe-sorts by who owns which decision in the loop
AI-capability level frameworksLevels by model capabilityLevels by delegated improvement responsibility, separate from quality
Memory/skill work (ReasoningBank, ACE, Trace2Skill, Metis, Library Drift)Ways to distill and store experienceTreats admission, activation, faithful use, and retirement as separate measurable steps

Results & Evidence

Headroom-Closed Index in 2026: graduate science 85.8, software engineering 52.6, tool agents 39.9. Higher means more of the launch-day gap is closed.

There are no new benchmark experiments. The evidence has three layers, and they deserve different levels of trust.

1. HCI capability analysis (moderate trust, careful method).

  • 393 model-benchmark observations across ten domains, 2023 to Sept 2026.
  • Only 17 of the 33 latest-model results could be linked to stable protocol families. The other 16 (Terminal-Bench, BrowseComp, others) were excluded from the curves. This is honest, but it also means the agentic domains rest on thin, shifting data.
  • 2026 HCI: math 86.4, grad science 85.8, broad knowledge 77.2, legal 64.5, multimodal 62.2, academic breadth 60.4, search/terminal 56.8, software engineering 52.6, tool agents 39.9. Cybersecurity is 91.9 but uses changed subsets.
  • Trajectory shapes differ. Legal slowed from +48.2 to +4.9. Math sped up from +32.8 to +53.6. Multimodal jumped 59.7 and then flattened at +2.5.
  • What it shows: bounded, easy-to-verify skills are closing faster than long, stateful, tool-using workflows. What it does not show: that RSI will close that gap. The extension is the fixed 78% formula.

2. Literature classification (useful, but it is the authors’ judgment). Across levels, B0 to L2 are broadly demonstrated. L3 and L4 depend on the domain. End-to-end L5 exists only in bounded prototypes.

  • Software engineering: L2 is the strongest level (Self-Harness, Agentic Harness Engineering, DarwinX). L3 is emerging (Self-play SWE-RL, Socratic-SWE). L4 is “largely absent.” SICA and DGM show bounded L5.

  • Healthcare: L2 is the frontier. Most evidence comes from simulated or retrospective cases.

  • The key negative results the survey highlights:

    • HyperAgents’ 200-iteration run had no statistically significant final advantage from transferred meta-agents.
    • Weco’s AIDE2 got 7 accepted harness improvements over 100 unattended steps. But installing the evolved harness as the outer improver gave no significant efficiency gain.
    • STOP’s weaker-model runs regressed on average and sometimes gamed soft budgets.

    Effective recursion is still unproven.

3. Industry case reports (low independent trust, high practical value). All of these are internal measurements.

  • Theseus: a clean vs. noisy workspace changed pass rates by 21.7 to 51.6 points across 8 model-harness setups (30 tasks, 1,280 rubrics). A reconstructed environment (a Collection Map plus an Event Log) raised rubric scores 18.65 to 39.67 points with the model and harness held fixed. There was some scope creep. Takeaway: your environment’s state can cap agent performance more than the model does.
  • Humanlaya: V0 vs. V4 of a quality-control agent system, same base model, tools and budget, 600 held-out task packages. Key defects fell from 9.0% to 3.7%. Handling time fell from 48 to 27 minutes per task.
  • Lark: graph-based retrieval raised human-rated usability from 52% to 65%. The automated evaluator agreed with humans about 84% of the time and was stricter than humans.
  • A-Evolve-Training: 0.80 to 0.86 over four autonomous post-training rounds on a 30B model. The top human submission scored 0.87.

Caveats to hold on to. Several case studies come from the authors’ own affiliated labs. The future model names and figures (GPT-5.6, Kimi K3 and others) come from vendor announcements. And the survey’s own standard, effective recursion under matched budgets, is one that almost none of the cited work meets, including the authors’ own.

How You’d Use It

The framework is more useful than any single cited system. Use it as an audit lens first and a build guide second.

Your harness (the strongest fit).

  • Where it slots in: draw your agent runtime’s improvement loop with the eight-part anatomy. Most teams find they run B0 everywhere (retries, self-critique) and maybe one L1 loop (a human-written skill applied at scale). Few have a real verifier between “the agent wrote a memory” and “the next task reads it.”
  • What it improves: put an admission gate in front of every persistent write: skills, memory entries, harness or prompt edits. Use a paired run on the same tasks with and without the change. Add a cap and retirement policy on the skill library, driven by an evidence log. This blocks the silent L4 failure where one bad lesson poisons hundreds of later runs.
  • What it costs: a fixed replay set of 20 to 50 representative tasks, double the eval runs per candidate, and a JSONL log. A few days of work.
  • What must be true: you can replay tasks cheaply and score them without the same model judging its own work.

Your automations and business processes.

  • Where it slots in: any pipeline with a checker, such as document extraction, data QA, ticket triage or code review bots. Copy Humanlaya’s two loops. The inner loop repairs this batch (check, refine, deliver-check). The outer loop runs across batches. It groups recurring failures, proposes a versioned change to the checker’s rules, prompts and few-shot examples, tests it on held-out items, and has a human approve it.
  • What it improves: you stop fixing the same class of defect by hand every week. Humanlaya’s internal numbers show the scale on offer: defects cut by more than half, handling time down about 44%.
  • What it costs: versioning your prompts and rules as artifacts, a held-out set, and a weekly human review slot.
  • What must be true: failures recur in groupable patterns, and you can tell “the input is bad” from “the checker is wrong.” That exact confusion was their worked example.

Your workflows and methodologies.

  • Where it slots in: reading papers and vendor claims. Before believing “our agent improves itself,” ask the three loop questions. Then ask: structural or effective? Matched budget? Was the evaluator protected from the thing being optimized?
  • What it improves: you stop paying for hype. Most “self-improving” products are an L2 prompt optimizer, or an L4 memory without a gate.

Your business.

  • Where it slots in: deciding where to invest in automation. The HCI analysis and the Theseus results point the same way. The gains left on the table are in long, stateful, tool-heavy workflows, and those are often limited by environment and data quality, not the model.
  • What it improves: budget allocation. Cleaning the workspace your agents operate in (an index of what exists, an event log of what happened) may beat a model upgrade.
  • What must be true: you measure on your own tasks, not on public leaderboards.

Build Your Own (Minimal Recipe)

The smallest version that gets about 80% of the value is a gated L4 skill loop on top of an agent you already have. Skip L5 until L4 is stable and measured.

Components:

  1. Replay set. 30 to 50 real tasks with automatic or rubric scoring, split into dev (used by the loop) and protected (never shown to the improver). This is your verifier.
  2. Trace capture. Store each run as compact JSON: the task, the tool calls, the outcome, and the errors.
  3. Distiller (the improver). An LLM call that reads N failed and N successful traces. It proposes 1 to 3 candidate skills. Each one has a hypothesis (“agent forgets pagination, so add a check-pagination step”) and a predicted effect. Use separate error and success analyst prompts, as Trace2Skill does.
  4. Paired gate. Run the dev tasks with and without each candidate. Admit only if it beats a minimum effect size and causes no regression on the protected set.
  5. Skill store with an evidence log. Markdown skill files plus an append-only JSONL file (skill_id, task_id, used, followed, outcome). Cap the store at about 30 to 50 active skills.
  6. Retirement job. Weekly. Retire skills whose measured contribution has faded. Do not over-retire; the Library Drift study found that hurts.
  7. Activation check. Log whether a relevant skill was retrieved and whether the agent followed it. These are the two failure modes that make updates useless.

Build order: 1, then 2, then 4 (gate the skills you write by hand first), then 3, then 5, 7, and 6. Getting the gate working before the distiller is the main point. A generator without a gate is how errors become inherited.

The hard parts:

  • A verifier you can’t game. If the same model writes skills and judges them, they share blind spots. Use executable checks where you can, and keep the protected set really hidden.
  • Attribution. A failure might come from the data, the context, the tool, the model, or the evaluator. Force the distiller to name its suspected component, and test that guess.

Libraries and models: any agent loop you already run. DSPy or GEPA if you want an L2 prompt optimizer inside the loop. A cheaper model is fine as the distiller (updating skill is not tied to model size). Put your strongest model on the solver.

Optional step to L5 (later): make the distiller’s prompt a versioned artifact. Every few epochs, propose a revised distiller. Keep the gate’s protected set and scoring frozen, RQGM-style. Then run effective_recursion_test: old distiller vs. new, same seed agent, same budget, fresh tasks. Promote it only if it wins.

How to Improve It

  1. Score effective recursion, not just structure. Build a small public harness that runs old vs. new improver from the same seed, under matched total compute (including the cost of evolving the improver), across 3 or more seeds. Report the full trajectory, including rejected updates. The survey asks for this and nobody provides it.
  2. Make component attribution a first-class step. Before proposing a fix, the improver should name the component it blames (data, context, tool, model, evaluator) and run a targeted ablation to confirm it. Test this: does blame-then-fix beat fix-directly on fix acceptance rate and regression rate?
  3. A standard provenance record for every inherited change. Use one format that links parent state, proposed change, motivating evidence, eval config, acceptance decision, and later uses. The paper sketches this in its “reproducible infrastructure” direction. Shipping it as an open schema and library would make L4 and L5 claims checkable.
  4. Adaptive stopping. Teach the loop to stop, pause, or escalate when the expected value of the next round falls below its cost. Measure total cost to reach a target capability, not just the final score.
  5. Fix the HCI projection. Swap the fixed 0.22 factor for per-domain fitted curves with uncertainty bands. Weight agentic domains by how stable their protocols are. As it stands, the figure that looks the most quantitative is the weakest part of the paper.

Glossary

  • RSI (Recursive Self-Improvement) - An AI turns experience into lasting changes to itself, and those changes can also change how it improves next time.
  • Improvement loop - The repeating cycle: gather experience, propose a change, verify it, keep it, start again from the new state.
  • Improver - The part that turns current state plus experience into candidate changes, usually an LLM call or a program around one.
  • Verifier / acceptance rule - What decides if a candidate is kept: tests, a judge model, a human, or a mix.
  • System state - Whatever survives a round: weights, memory, skills, harness code, research policy.
  • Successor - The version of the system that starts the next round with the accepted changes.
  • B0 - In-task refinement only. The output gets better, the system does not.
  • L1-L5 - Execution, strategy, experience, deployment and meta autonomy. Each adds one improvement decision the AI owns.
  • Structural recursion - A revised improver, verifier, or policy really governs a later round.
  • Effective recursion - That revision really produces better successors at the same budget, under independent evaluation.
  • HCI (Headroom-Closed Index) - The percentage of a benchmark’s launch-year remaining gap that a model has closed. 0 = launch frontier, 100 = perfect.
  • Protected evaluation - A test set or judge the improver cannot see or change, so gains are not just learned exploits.
  • Trajectory distillation - Compressing raw agent run logs into short reusable lessons, skills, or tools.
  • Paired-run gate - Admit a change only after running the same tasks with and without it and seeing a real difference.
  • Library drift - A skill or memory library slowly getting worse as it grows, because retrieval degrades.
  • Evaluator co-evolution - Improving the judge alongside the solver. This is only safe with frozen epochs and a fixed anchor.
  • Learner-conditioned curriculum - Choosing the next practice tasks based on what the current model is weak at.
  • Self-play - The system creates its own problems or opponents to learn from (as in Absolute Zero or R-Zero).
  • GRPO / RL post-training - Training a model with a reward signal on its own sampled outputs. GRPO scores each sample against the group average instead of using a value model.
  • Harness - The scaffolding around a model: prompts, tools, memory rules, control flow.