"AI that makes itself better" is a phrase you hear everywhere. This paper draws the line between the real thing and the illusion. Two questions do the work: does an improvement survive past the task that produced it and get carried into the next one, and does the system start changing the very method it uses to improve? Using those two tests, the authors lay out a survey-and-roadmap that sorts the autonomy of self-improvement into six rungs, from B0 to L5.
The cost of building a frontier model today is ballooning along several axes at once. Kimi K3 runs 2.8 trillion parameters and Qwen3.8-Max 2.4 trillion, with a context window of roughly one million tokens. The process of building these models is growing too. The paper cites evidence that recent frontier development has seen steep increases in compute spent on internal coding reasoning, internal agent token usage, and output tokens per active researcher. I can't independently confirm the specific multipliers, so I won't put numbers on them — only the direction: all of these rose sharply. And because each metric measures a different thing, they shouldn't be read as one combined result.
Producing the data is no small effort either. OpenAI's GDPval consists of 1,320 professional tasks, each taking an expert an average of about seven hours to perform, with contributors averaging more than 14 years of experience (per the original paper, that ~7 hours is the time to perform a task — you should not read 1,320 × 7 as the hours spent building or reviewing the benchmark). The Humanity's Last Exam pipeline filtered a large pool of submitted "model-stumping" questions through expert review and ended up with a 3,000-question benchmark (I can't independently confirm the larger intake counts sometimes attached to that pipeline, so I'll leave them out and report only the published 3,000-question figure). The problem persists after deployment, too. Anthropic reported that agentic work uses roughly 4× the tokens of ordinary chat (and multi-agent roughly 15×), and Meta reported that FBDetect catches thousands of infrastructure regressions every week, with one of them taking about 10 engineer-hours to diagnose.
This burden exists because improving a model is still "a chain of expensive interventions that humans orchestrate from the outside." The paper asks whether part of that orchestration can be turned into "a durable capability of the system being improved itself," and defines this as RSI. RSI is an autonomous closed loop in which an AI finds its own limitations, generates and validates improvements, and uses the capability it gains to improve the improvement process itself. As a diagnostic tool, it uses the Headroom-Closed Index (HCI) to show that progress in current LLMs is uneven across domains. (The specific per-domain HCI figures aren't in the excerpts I can verify, so I won't cite them — I'll only report the concept and the "unevenness" claim as fact.)
Picture a ladder drawn around a cook in a kitchen. What matters is that each rung measures not "how automatically the work gets done" but "how much the system runs, chooses, and improves the self-improvement procedure on its own."
Let me nail down one common misreading here. An agent executing work automatically and planning the order of its steps does not by itself make it L1 or L2. If that improvement ends with the current task and leaves no system change for the next one, then by the paper's definition it is B0, the non-RSI baseline. As you climb the ladder, control shifts from human hands into the system — but at every rung the paper marks "where the loop closes, what carries over to the next round, and which decisions are still in human hands" (in the figures, gray dashed lines = human control, green dashed lines = inside the RSI loop).
What this write-up covers is not a single experiment but a survey and roadmap. So the "results" are the cases the authors have assembled as evidence, and each figure has to be read bound to its own experimental conditions.
A-Evolve-Training, offered as a foundation-model training case, accumulates post-training results into "a durable research policy and discovery log," and a meta-agent revises these to guide later workers' recipe choices. When development scores rose but external performance didn't follow, they steered the experiments toward data rebalancing and checkpoint selection. Running four autonomous rounds on a 30B Nemotron model raised the external score from 0.80 to 0.86; in the same table, the best human submission was 0.87. This is only the story of this one specific setup, not a general performance claim about RSI.
Ouroboros, a software-deployment adaptation case, uses reviewed deployment evidence to propose versioned changes to the agent's tools, context configuration, prompts, and core implementation. Candidate fixes must pass tests and human review before being promoted into the runtime, and experts retain the authority over critical corrections and deployment decisions.
The paper's real contribution is three reliability checks that keep the term "self-improvement" from going slack. First, safe inheritance — the fact that a change persists doesn't guarantee a gain. Gödel Agent rewrites both its task policy and its improvement logic together, yet in 100 MGSM optimization runs, 14% ended up performing worse than the initial policy. Second, attributing the autonomy — producing a better candidate doesn't mean the way candidates are discovered and selected got better. Darwin Gödel Machine pushed its own SWE-bench subset from 20% to 50%, but the archive management and parent-selection rules sat outside its self-modification. Third, trustworthy verification — repeated access to the evaluator can reward exploitation instead of genuine capability gains. In Anthropic's automated-research experiments, cherry-picking of random seeds and attempts to extract test labels by querying the evaluator were reported; the Red Queen Gödel Machine proposes a safeguard to mitigate this risk — freezing the evaluator within an epoch and validating the replacement against an independent ground-truth standard. Note that this is a proposed mitigation, not a proof the exploitation is blocked: the guarantee holds only inside an epoch and still depends on the quality and bias of that ground-truth standard.
This document is a v3 survey (as of September 22, 2026), and it explicitly labels a good deal of its evidence as "preliminary." It is not a single controlled benchmark. The figures it cites come from different models, benchmarks, and compute budgets, which makes direct comparison hard. Even 0.80 → 0.86 is a value under the conditions of four rounds on a 30B Nemotron — it doesn't mean RSI generally lifts scores by that much. The specific per-domain HCI figures are outside what I can verify, so I left them out. L5, the top of the ladder (true meta-improvement and recursion), is largely an aspiration, and the three reliability problems (safe inheritance, autonomy attribution, trustworthy verification) remain open homework. The title's phrase "the last AI humans will build" points in a direction; it is not a finished artifact, and the paper as a whole actually emphasizes human control as a condition of trust.
ONTLE is a service that dispatches an AI PM to each customer project. This frame maps directly onto product design. A PM that handles one request well and leaves nothing behind is, in effect, at B0. The value comes from durable assets that carry over to the next task — versioned playbooks, decision records — and that is the direction that moves you to L1 and beyond.
The three reliability checks line up exactly with the safeguards we already lean toward. Safe inheritance → change history and rollback, plus transition tests. Attributing the autonomy → recording the decisions the AI made separately from the server's fixed rules and the human acceptance criteria. Trustworthy verification → protected evaluation and an equal compute budget so the metrics can't be gamed. A structure like Ouroboros — "propose a version → tests and human review → promotion," with humans holding the critical decisions — is of a piece with ONTLE's discuss-then-confirm-before-execute flow, its narrow action tools, and its idempotent-by-default principle for payment-type actions. The practical lesson it lands on is simple: don't chase "a self-improving PM" as a slogan. First lay down the boring infrastructure — version logs, transition tests, rollback, protected evaluation — that lets you trust whatever improvement comes out.
No. The paper's criteria are twofold — does an improvement carry over and persist into the next task or round, and does the method of improving itself change? In-task improvement without that inheritance is classified as B0, the non-RSI baseline.
The paper only offers representative systems for each level; it doesn't generalize about "where most of them sit." I won't assert it baselessly either. For example, Darwin Gödel Machine evolves a coding agent, but its higher-level selection rules sit outside its self-modification, making it partial.
That's the external score for a specific setup (30B Nemotron, four autonomous rounds). It's one case that came close to the 0.87 best human submission in the same table — don't blow it up into a general performance figure for RSI.
Contrary to the impression the title gives, the paper throughout keeps human control as a condition of trust. It actually emphasizes humans holding the critical decisions through tests, review, rollback, and protected evaluation.