On September 14, 2026, seventeen researchers from Google, Google DeepMind, the University of Maryland and the University of Virginia posted a paper called Dream-RSI: Recursive Self-Improvement through Evolving Worlds. Two days later a post summarizing it passed 100,000 views on X with the opener “Google just demonstrated a recursive self improvement loop for AI discovery”. The paper is real, the affiliation is real, and the headline number is real once its baseline is attached. This page holds the facts and the baselines, and reads the paper against a week in which recursive self-improvement has been the argument.
On this page · 7 sectionsOpen
Dream-RSI: Recursive Self-Improvement through Evolving Worlds was posted to arXiv on September 14, 2026 (2609.14858) by 17 authors from Google, Google DeepMind, the University of Maryland and the University of Virginia. The GitHub repository was created September 13; as of 15:00 UTC on September 16 it had 169 stars and its README says the code is being prepared for release.
The mechanism is an orchestration layer around a coding agent that does not change. The agent’s completed searches form a discovery tree; the tree is used as a replay simulator in which thousands of alternative exploration policies are scored without new runs, and the winning policy is deployed for the next round. In the paper’s words, only the exploration-policy code changes; the models, evaluator and execution interfaces remain fixed.
The headline numbers carry baselines. On a Lasso path solver it beats sklearn and cuts discovery-agent calls by up to 162 times against SimpleTES, and 1.7 times against fixed exploration. On three math problems it matches or beats AlphaEvolve-class systems within 1,000 generations with over 50 times the budget savings against SimpleTES. On four KernelBench kernels it reaches target speed with 1.79 to 2.43 times fewer generations, or 2.09 times better performance at the same budget.
What did not move: any weight. The discovery agents were Gemini 3.1 Pro and Gemini 3.7 Flash through the Gemini CLI; a separate fixed agent rewrites the exploration policy as code. The paper places itself against prior work that evolves model weights, agent harnesses, contexts or skills, and improves none of those directly.
The post that carried it (Dr Singularity, 12:46 UTC on September 16, 112,417 views by 15:10 UTC) says Google just demonstrated the loop and quotes the 162 times without its baseline. The paper is two days older than the post, and the 162 is against one baseline on one task; against fixed exploration the same task shows 1.7 times.
Two days after Dario Amodei named recursive self-improvement as the first trigger for pacing the frontier, a Google paper published a recursion that improves the program around the model rather than the model. That is the half we argued a product company can build and audit; the paper’s own framing, exploration made explicit and programmable, is the same distinction.
§ 01The paper, in one loop
The first sentence of the abstract sets the frame: “Recursive self-improvement is becoming increasingly vital for autonomous AI agents”. The problem the authors pick is not the model. It is the search: when a coding agent hunts for a better algorithm or a faster kernel, something decides how many branches to open, how far to refine each one and when to stop. That something is the exploration policy, and the paper’s diagnosis is that “fixed strategies fail to adapt as search spaces scale” while tuning the policy online is slow and expensive, because every trial means running the agent again.
The move is to stop running the agent to test a policy. Every completed search leaves a discovery tree, the record of which branches were tried and what each one scored. The authors’ insight is that “accumulated discovery history can serve as a replay simulator over the realized search space”. A candidate policy can be walked through the recorded tree and scored on outcomes already paid for. The project site puts it in one line: “History is the world it dreams in.” Thousands of candidate policies are scored this way at no execution cost, one winner is deployed for the next online round, that round adds a new tree to the pool, and the loop repeats.
The architecture is explicit about what moves and what does not. “A lightweight orchestration layer makes exploration explicit and programmable while leaving the underlying coding agent unchanged.” A second, fixed agent reads the replay scores and revises the policy as code. And the sentence we will come back to: “Only the exploration-policy code changes; the underlying models, evaluator, and execution interfaces remain fixed.”
§ 02The numbers, with their baselines
| Domain | Tasks | Result | Baselines |
|---|---|---|---|
| Algorithm engineering | Lasso path solver | Beats sklearn and strong baselines; up to 162x fewer discovery-agent calls against SimpleTES; 1.7x fewer against fixed exploration | SimpleTES; Recursive Fixed Exploration |
| Mathematical optimization | Sum-difference, autocorrelation, circle packing | Matches or surpasses strong baselines within 1,000 generations; over 50x budget savings against SimpleTES | SimpleTES; AlphaEvolve, AlphaEvolveV2, OpenEvolve, CodeEvolve, ShinkaEvolve, TTS-Discovery, ThetaEvolve, EvoX |
| GPU kernel engineering | VGG16, LayerNorm, ConvDiv, ConvMax (KernelBench) | Reaches target speed with 1.79x to 2.43x fewer generations, or up to 2.09x better kernel performance at the same budget | Recursive Fixed Exploration |
Three things to hold alongside the table. The largest number, 162x, is against SimpleTES, a test-time-search baseline, on one task; the comparison the paper itself treats as the fair one, a fixed exploration policy with the same agent and the same budget, gives 1.7x on that task and 1.79x to 2.43x on the kernels. The discovery agents were Gemini 3.1 Pro and Gemini 3.7 Flash through the Gemini CLI, so the results are Google’s agents improving Google’s search, which does not make them wrong but does make them one lab’s numbers until someone reproduces them. And the code is not out: the repository was created on September 13, its README says “Code is being prepared for release.”, and the arXiv badge on that README still reads coming soon while the paper is live.
| When | What |
|---|---|
| Sep 10 | CellCog publishes the two-halves-of-recursion essay |
| Sep 12, 14:01 | Dario Amodei publishes We Must Pace the Frontier, naming recursive self-improvement as the first trigger |
| Sep 13, 20:39 | The Dream-RSI GitHub repository is created |
| Sep 14 | Dream-RSI is posted to arXiv |
| Sep 16, 12:46 | Dr Singularity’s post; 112,417 views by 15:10 |
§ 03What stayed fixed
The paper’s related-work section sorts self-evolving agents by what they change: “Prior methods evolve model weights”, or agent harnesses, or contexts, or skills. Dream-RSI changes none of those on purpose. The weights are Gemini’s as shipped. The evaluator that scores candidates is fixed. The tools are fixed. The one thing that improves is a program, the exploration policy, rewritten by an agent that reads the record of what past policies did in the trees they already built. The site describes that record as “a world that came free, as a by-product of working”.
That is a narrow claim and the authors keep it narrow. The framework is scoped to discovery tasks with an evaluator that can score a candidate, which is why the domains are a solver, three optimization problems and four kernels, all with a number to beat. Nothing in the paper is about an agent improving its judgment, its honesty or its reasoning. It is about an agent getting better at choosing where to look, and paying less to find out.
§ 04What the post added, and what it dropped
The post that carried the paper to 112,417 views in under three hours was accurate on the mechanism. Its last line, “Importantly, it improves the exploration policy, not the underlying model weights.”, is the paper’s own distinction. Two things it changed. “Google just demonstrated” describes a paper that was two days old and a repository that was three; the demonstration is the paper, and the paper is dated September 14. And “reducing agent calls by up to 162x” stands alone in the post; in the paper it stands beside 1.7x on the same task against the fairer baseline. Both numbers are Google’s. Only one of them travels.
§ 05Where this sits in the week
Our conflict, declared: we build CellCog, a platform where AI employees keep memory, rules and mistakes across working sessions, review each other’s work and revise the operating manual they run on. Read what follows as a company with a stake reading a paper about its category.
On September 10 we argued that self-improving AI has two halves. One is the model improving the model, which happens inside a lab. The other is the harness improving the harness: an agent makes a mistake, catches it, and writes the rule that prevents it into the system every future agent inherits, while the weights never move. Two days later Dario Amodei named recursive self-improvement as the first of two triggers for pacing the frontier, and the argument of the week has been about the first half.
Dream-RSI is the second half, published by the largest lab in the argument. The recursion is a program that reads a record and rewrites itself; the model it steers is untouched; the whole loop runs in code a reviewer can open. The paper’s own vocabulary, exploration made explicit and programmable, is the property we care about: an improvement you can diff is an improvement you can audit. None of this is a claim that the second half is safe by construction. A policy that learns to search better is a policy that finds more, and the paper’s own domains include finding faster kernels. It is a claim about where the improvement lives, and that, in this paper, it lives somewhere you can read.
§ 06What we are watching for
- The code. The README promises a release; whether the orchestration layer and the policy-development agent ship, and under what license, decides whether anyone outside Google can reproduce 1.7x, never mind 162x.
- A reproduction on a non-Gemini agent. The paper’s agents were Gemini 3.1 Pro and 3.7 Flash. The first independent run on a different coding agent tells whether the gain belongs to the method or the pairing.
- Whether the labs’ pacing talks name this class of recursion. Amodei’s essay and the week’s replies are about model capability. A framework that improves search around a fixed model is either inside that conversation or outside it, and nobody has said which.
§ 07Sources
Tong Zheng et al., Dream-RSI: Recursive Self-Improvement through Evolving Worlds, arXiv 2609.14858, submitted September 14, 2026 (PDF read September 16, 2026); the project site dream-rsi.com and repository zhengkid/Dream-RSI (created 2026-09-13T20:39:43Z; 169 stars and README read at 15:11 UTC on September 16, 2026). Dr Singularity, post on X, 2026-09-16T12:46:54Z, 112,417 views at 15:10 UTC. Dario Amodei, We Must Pace the Frontier, September 12, 2026, as recorded in our pace record. CellCog, Self-Improving AI Has Two Halves, September 10, 2026. KernelBench task names and the AlphaEvolve-family baselines are as listed in the paper.
Q1Who wrote Dream-RSI and when was it published?
Seventeen authors led by Tong Zheng, with corresponding authors Xidong Wu and Zheng Zhang of Google; affiliations are Google, Google DeepMind, the University of Maryland at College Park and the University of Virginia. The arXiv listing is dated September 14, 2026 (2609.14858, 12 pages plus appendices, cs.CL).
Q2Does Dream-RSI change the model's weights?
No. The paper states that only the exploration-policy code changes and that the underlying models, evaluator and execution interfaces remain fixed. The discovery agents in the experiments were Gemini 3.1 Pro and Gemini 3.7 Flash via the Gemini CLI.
Q3What is the 162 times figure?
The reduction in discovery-agent calls on the Lasso path solver task against SimpleTES, one of the baselines. Against Recursive Fixed Exploration on the same task the reduction is 1.7 times. Both numbers come from the paper’s introduction.
Q4How is this different from AlphaEvolve?
AlphaEvolve and its relatives evolve candidate programs under a fixed search strategy. Dream-RSI keeps the candidate-generating agent fixed and evolves the search strategy itself, using the recorded tree of past attempts as the test bed. The paper compares against AlphaEvolve, AlphaEvolveV2, OpenEvolve, CodeEvolve, ShinkaEvolve, TTS-Discovery, ThetaEvolve, EvoX and SimpleTES on the math tasks.
Q5Why does an AI-employee company care?
Because the recursion here happens in a program you can read, around a model nobody retrained. That is the same shape as an AI employee that rewrites its own operating rules from its own record while the model stays as the vendor shipped it, and the same half of self-improvement we argued leaves an audit trail.