Quick Answer:
No, Google has not achieved recursive self-improvement in the science-fiction sense of an AI rewriting its own brain. On 13/11/2026, researchers from Google Cloud AI, Google DeepMind and Penn State published a preprint (arXiv 2611.18856) on harness-level recursive self-improvement: an LLM optimiser repeatedly rewrites the prompts, tools and control code around a frozen model. Their contribution, Self-Improvement Memory (SIM), is a structured record of why each edit was made and what happened, which lets that optimisation continue when the model or benchmark changes. Across ten paired coding runs (Terminal-Bench 2.1 to Terminal-Bench 4), continuing with SIM beat continuing without it in 9 of 10 pairs, by 2.36 points on average (95% CI 1.05 to 3.68, p = 0.003). It is a useful, carefully reported result about agent engineering, not evidence of runaway self-improvement, and the authors say so themselves.
"Google ACHIEVED RSI?!" is the kind of headline that spreads fast, and this week it attached itself to a modest-looking paper with a long title: Self-Improvement Memory Enables Continual Recursive Self-Improvement. The paper is real, the numbers are real, and the work genuinely touches recursive self-improvement. But what it shows is narrower, more practical and arguably more interesting for anyone who builds AI agents: when you hand an automated optimiser a new model or a new benchmark, it does better if it can read the lab notebook from its previous run. This article explains what Google actually did, what every key number means, where the evidence stops, and what you can take from it today.
+2.36
Mean score-point gain with SIM
Ten paired coding continuations, TB2.1 to TB4
9 / 10
Paired runs favouring SIM
One pair favoured no SIM by 0.61 points
[1.05, 3.68]
95% confidence interval
Paired t(9) = 4.06, p = 0.003
−0.8
CRSI vs fresh RSI on Gemini 4 Argon
94.8 vs 95.6 on held-out TB2.1 (Table 1)
Source: Yu et al., Self-Improvement Memory Enables Continual Recursive Self-Improvement, arXiv 2611.18856 (13/11/2026).
WorldofAI's news round-up asks whether Google has achieved recursive self-improvement and covers the continual RSI paper alongside other news. The headline framing is the creator's; the paper itself makes narrower claims.
Executive Summary
- What it is: A preprint by Xin Yu and nine co-authors from Google Cloud AI, Google DeepMind, Google Cloud AI Research and The Pennsylvania State University, submitted to arXiv on 13/11/2026. The work was done during Xin Yu's internship at Google. It has not been peer-reviewed.
- The setting: Continual recursive self-improvement (CRSI) means continuing an automated harness-optimisation run after the benchmark or the policy model changes, instead of starting again.
- The method: Self-Improvement Memory (SIM) is memory for the harness optimiser, not for the task-solving model. It records each accepted edit's problem, rationale, predicted fixes, observed outcomes and evaluation context.
- Headline evidence: Ten independent coding source runs, each continued twice from the same harness. SIM won 9 of 10 pairs, mean +2.36 points (21.70 vs 19.33), 95% CI [1.05, 3.68], p = 0.003.
- Broader evidence: Across coding, text classification, agentic workspace tasks and engineering design, Full SIM finished highest in all six cross-dataset and all four Claude Opus 5.5 to Gemini 3.8 Flash settings. These are single runs per condition.
- The honest caveat: Carrying the harness and SIM through Gemini generations beat fresh optimisation on Gemini 3.5 Flash and 3.8 Flash, but finished 0.8 points lower on Gemini 4 Argon.
- The RSI question: Model weights stay frozen and the optimiser's search procedure is fixed. The authors explicitly say the study does not establish unbounded self-improvement or universal transfer.
Did Google Achieve Recursive Self-Improvement?
Recursive self-improvement (RSI), in its classic AI-safety meaning, is a system that improves its own ability to improve itself, so that each generation is better at producing the next. That is the scenario behind warnings such as Jakub Pachocki's, covered in our piece on OpenAI's "An Alien Mind" essay, and Sam Altman's comments in his three AI endgames. Our longer primer, AI recursive self-improvement, explained, covers the history of the idea.
The Google paper uses the term in a narrower, engineering sense that has become common in 2026 agent research. Here, "RSI" refers to a loop in which an LLM-based optimiser proposes changes to an agent's harness, runs them, scores them and keeps the best, round after round. The model doing the actual tasks is never retrained. In the paper's words, "Policy weights remain frozen."
So the plain answer is: Google researchers demonstrated a better way to keep harness-level self-improvement going across model and benchmark changes. They did not demonstrate an AI that improves its own intelligence without limit. The project page says this directly: the study "does not establish unbounded self-improvement, universal transfer, or the isolated causal effect of every memory field."
Two further points keep the claim in proportion. First, the optimiser's own planning and search procedure is held fixed; the limitations section says the authors "keep the optimizer's planning and search procedures fixed." The improver does not improve itself, which is the recursive part that matters most in safety debates. Second, the gains are a few points on specific benchmarks, measured over ten optimisation rounds. That is meaningful for agent engineering. It is not an intelligence explosion.
The companion research atlas from the same lead author makes the distinction explicitly: "Task gains alone do not establish better subsequent optimization or general RSI." That is a more careful position than most of the coverage, and it deserves credit.
What Is Harness-Level Recursive Self-Improvement?
An agent harness is all the software around a language model that turns it into an agent: the system prompt, the tools it can call, how its context is assembled, its memory, and the control logic that decides when to stop or retry. The paper describes it as the layer that "manages context, tools, and execution." If you have used Claude Code, Codex, Google Antigravity or Hermes Agent, you have used a harness. The same model can perform very differently in different harnesses.
Harness-level recursive self-improvement automates the work of improving that layer. Following Meta-Harness, the paper's loop has three LLM-driven roles around a frozen task model:
- Evaluator: runs the current harness on an "evolve set" of tasks and returns scores, traces and errors.
- Proposer: reads that feedback, the run's code and history, and proposes k candidate harness edits (k = 5 in every run).
- Selector: screens proposals, then chooses among the evaluated candidates, weighing performance, complexity, domain specificity and regression risk.
Each run lasts N = 10 rounds. A separate held-out task set is used only to measure results, and its feedback never reaches the optimiser. That separation matters: a self-modifying harness could otherwise learn to satisfy the test rather than solve the task, a risk the authors name in their ethics statement.

Until now, most work like this has been studied in a fixed setting: one model, one benchmark. Real agents do not live in a fixed setting. Models are replaced every few months, and the tasks shift. The paper identifies two concrete situations: multi-model serving, where one harness must support several models, and model evolution, where a new version replaces an old one in the same family. Google's own release pace, from Gemini 4 Argon in September to Gemini 4 Neon this month, is a good illustration of why that matters.
What Is Self-Improvement Memory?
Self-Improvement Memory (SIM) is a structured record, kept for the harness optimiser, of every accepted harness edit, grouped by the recurring problem it was meant to fix, together with its rationale, predicted and observed outcomes and the setting in which it was tested. The tagline on the project page captures it: "Keep the code. Remember why."
The motivation is simple. When an evolved harness moves to a new model or benchmark, the code survives but the reasoning does not. A check that says "verify completion" is visible in the code; why it was added, what failure it fixed, and which alternatives were tried and rejected are not. The next optimiser has to guess, and may repeat old mistakes or delete something important.
What does a SIM record contain?
According to the paper's implementation appendix, each run stores SIM as one JSON file. Each problem entry has an id, a root-cause name (for example "premature completion without execution verification") and the round in which it was first diagnosed. Under it sits a list of attempts, each recording:
| Field | What it records |
|---|---|
| what, files | The edit and which harness files it touched |
| predicted | Tasks the edit is expected to fix, written before evaluation |
| fixed, missed | Which predictions came true after evaluation |
| passed / total | Successful and total evolve-set trials for that attempt |
| accepted | Whether the selector chose it, even if some predictions failed |
| round, domain | Provenance: when and in which setting it was tested |
Three design choices stand out. First, failures are kept: a selected edit is recorded "even when the edit regresses or fails to fix a predicted task." Second, history is append-only; new attempts are added to an existing problem or open a new one, and entries with identical root-cause text are merged without losing attempts. Third, there is no retrieval: the proposer gets "the complete SIM in its system prompt," and the selector reads the same record, "without retrieval or truncation." That keeps the method simple but means token cost grows with the memory.
The prompt guidance tells the optimiser to treat entries as prior experience rather than rules, to check the domain, benchmark and model behind each entry, to reuse rationales but reassess edits after a change, and to give task-specific evidence less weight when both benchmark and model have changed. In short, SIM is the optimiser's engineering notebook.
It is worth being clear about what SIM is not. It is not memory for the agent while it solves tasks, like Claude's user memory or the example store in the text-classification harnesses. The paper separates these explicitly: task memory "is separate from SIM, which supports harness optimization."
How Did Google Test It?
The study covers four domains where an evolved harness can still run after the switch. In each, tasks were split at random into roughly equal evolve and held-out halves, with five rollouts per task.
| Domain | Source benchmark | Target benchmark | Metric | Seed harnesses |
|---|---|---|---|---|
| Coding | Terminal-Bench 2.1 (89 tasks) | Terminal-Bench 4 (66 tasks) | pass@1 | AHE, Terminus-2 |
| Text classification | 3 datasets (412 examples) | 8 unseen datasets (1,000 examples) | Accuracy | NoMemory, FewShotAll |
| Agentic workspace | Harvey LAB (160 tasks) | JobBench + GDPval + APEX-Agents (765 tasks) | Equal-weight mean | ReAct agent |
| Engineering design | EngDesign (67 tasks) | Frontier-Eng (47 tasks) | Pass rate / medal score | ReAct agent |
The policy model, meaning the model that actually does the tasks, is Gemini 3.8 Flash in the cross-dataset experiments. For cross-model transfer, the source run uses Claude Opus 5.5 and Gemini 3.8 Flash continues on the same benchmark and split. Gemini 3.8 Flash also plays the proposer and selector roles in the main comparisons. Workspace tasks are judged by Gemini 3.8 Flash, which the authors flag as a potential source of judge bias.
The four comparison conditions
- Cold Start: target optimisation starts from the original seed harness, with no memory.
- Harness Transfer: starts from the source-evolved harness, but with no SIM. This is how prior work usually transfers harnesses, and it is the direct control.
- Problem-Only Memory: the same evolved harness, plus a list of root causes only, without edits, outcomes or provenance.
- Full SIM: the same evolved harness plus the complete record, updated during target optimisation.
All four use the same target model, tasks, ten rounds and five candidates per round. Matching rounds is not the same as matching cost, a point we return to below. The paper puts a coding round at about four hours, including 1.7 hours of evaluation and 34 minutes of candidate sampling.
The Key Result: Ten Paired Coding Runs
The most important experiment in the paper is the one designed to answer "was it luck?" Most conditions are run once, so a single good run could be noise in the optimisation itself. To test that, the authors repeated source optimisation ten times from the Terminus-2 harness on Terminal-Bench 2.1 (TB2.1). Each of the ten resulting harnesses was then continued twice for ten rounds on Terminal-Bench 4 (TB4): once with that run's SIM and once without. Everything else in each pair was matched. The independent source run is the unit of analysis.
Final held-out TB4 score after ten target rounds, with and without SIM
Ten independent Terminus-2 source runs, each continued twice from the same evolved harness. Higher is better.
- Continue with SIM
- Continue without SIM
Run 1
Run 2
Run 3
Run 4
Run 5
Run 6
Run 7
Run 8
Run 9
Run 10
Mean
Show data table
| Benchmark | Continue with SIM | Continue without SIM |
|---|---|---|
| Run 1 | 22.42 | 20.61 |
| Run 2 | 19.39 | 17.58 |
| Run 3 | 20.61 | 20.00 |
| Run 4 | 23.64 | 18.18 |
| Run 5 | 20.61 | 18.79 |
| Run 6 | 23.64 | 20.00 |
| Run 7 | 21.82 | 20.00 |
| Run 8 | 19.39 | 20.00 |
| Run 9 | 23.03 | 18.18 |
| Run 10 | 22.42 | 20.00 |
| Mean | 21.70 | 19.33 |
Source: Yu et al., arXiv 2611.18856, Table 3. Policy: Gemini 3.8 Flash. Scores are pass@1 on a 0–100 scale.
From a shared mean starting score of 18.36, continuation with SIM reached a mean of 21.70 and continuation without it reached 19.33. SIM finished higher in nine pairs. Run 8 went the other way, by 0.61 points, and the authors kept it in the results and on the project page rather than hiding it. The mean paired advantage of 2.36 points has a 95% confidence interval of [1.05, 3.68], a two-sided paired t-test gives t(9) = 4.06, p = 0.003, a signed-rank check gives p = 0.006, and the standardised paired effect size is dz = 1.28.
| Run | Start | No SIM | SIM | SIM minus No SIM |
|---|---|---|---|---|
| 1 | 18.18 | 20.61 | 22.42 | +1.81 |
| 2 | 16.97 | 17.58 | 19.39 | +1.81 |
| 3 | 17.58 | 20.00 | 20.61 | +0.61 |
| 4 | 18.18 | 18.18 | 23.64 | +5.46 |
| 5 | 17.58 | 18.79 | 20.61 | +1.82 |
| 6 | 19.39 | 20.00 | 23.64 | +3.64 |
| 7 | 18.79 | 20.00 | 21.82 | +1.82 |
| 8 | 18.18 | 20.00 | 19.39 | −0.61 |
| 9 | 19.39 | 18.18 | 23.03 | +4.85 |
| 10 | 19.39 | 20.00 | 22.42 | +2.42 |
| Mean | 18.36 | 19.33 | 21.70 | +2.36 |
How big is 2.36 points, really?
In context, it is substantial. Without SIM, ten rounds of optimisation added about one point on average (18.36 to 19.33). With SIM, they added about 3.3 points. Put another way, the memory roughly tripled what the continuation achieved in these runs. In absolute terms, though, the scores are low: TB4 is hard for Gemini 3.8 Flash in these harnesses, and every final score sits between about 17 and 24 out of 100. Each TB4 held-out task is worth roughly three points, so 2.36 points is a little under one extra task solved on average. Note also that the held-out set is 33 tasks with five rollouts each.

The round-by-round curves add a second useful finding. Full SIM is best or tied in every round for both coding seeds, and it passes the strongest control's final score (20.61) by round 5 from the AHE seed and by round 2 from Terminus-2. If your optimisation budget is limited, getting there sooner matters as much as getting further.
Does SIM Help When the Benchmark Changes?
In cross-dataset CRSI, the model stays the same (Gemini 3.8 Flash) and the task distribution changes. Source optimisation worked: it raised held-out source scores in all six settings, by 2.75 to 6.41 points. The question is what happens next.
Cross-dataset CRSI: final held-out target score by condition
Score after ten rounds of target optimisation. Each domain uses its own metric, so compare within a row, not across rows.
- Full SIM
- Harness Transfer (no SIM)
- Problem-Only Memory
- Cold Start (seed)
Coding / AHE
Coding / Terminus-2
Text cls. / NoMemory
Text cls. / FewShotAll
Workspace / ReAct
Engineering / ReAct
Show data table
| Benchmark | Full SIM | Harness Transfer (no SIM) | Problem-Only Memory | Cold Start (seed) |
|---|---|---|---|---|
| Coding / AHE | 24.85 | 20.61 | 18.79 | 19.39 |
| Coding / Terminus-2 | 21.82 | 19.39 | 20.61 | 19.39 |
| Text cls. / NoMemory | 73.60 | 71.00 | 73.40 | 72.00 |
| Text cls. / FewShotAll | 77.92 | 74.12 | 75.52 | 75.92 |
| Workspace / ReAct | 87.89 | 85.07 | 85.54 | 82.98 |
| Engineering / ReAct | 46.96 | 42.61 | 42.61 | 40.87 |
Source: Yu et al., arXiv 2611.18856, Table 5. Single run per condition; five rollouts per task.
Full SIM finished highest in all six settings, between 2.43 and 4.35 points above Harness Transfer and between 0.20 and 6.06 points above Problem-Only Memory. The margin over the strongest alternative ranged from just 0.20 points (text classification, NoMemory seed) to 4.35 points (engineering).

Why does keeping only the root causes not work as well?
Problem-Only Memory had mixed effects, ranging from 1.82 points below Harness Transfer to 2.40 above. This is the closest thing the paper has to an ablation of SIM's contents, and it suggests the value is in the evidence (what was tried, what was predicted, what happened), not the diagnosis list alone. The paper does not ablate the fields one by one, which a commenter on Hugging Face Papers also asked about.
A better source harness can be a worse starting point
One of the paper's most practical findings is a warning. With the FewShotAll text-classification seed, source optimisation improved source scores, yet the evolved harness started the target suite below the original seed: 72.92 against 75.72. Harness-only continuation reached 74.12, still below Cold Start's 75.92. Only Full SIM (77.92) beat starting from scratch. In other words, carrying an optimised harness to a new task without its history can actively hurt, and SIM is what turned that inherited baggage into an advantage.
Does SIM Help When the Model Changes?
Cross-model CRSI keeps the benchmark and split fixed and swaps the model. Here, the harness was evolved with Claude Opus 5.5 as the policy, then handed to Gemini 3.8 Flash. This is the multi-vendor reality of many production agents, and the result is striking: the Opus-evolved harness started below Gemini's own seed harness in every domain, by 0.60 points in text classification up to 5.48 points in workspace tasks. An optimised harness for one model family was a handicap for another.
Cross-model CRSI (Claude Opus 5.5 to Gemini 3.8 Flash): final held-out score
Score after Gemini's ten target rounds. Benchmark and split fixed. Compare within a row.
- Full SIM
- Harness Transfer (no SIM)
- Problem-Only Memory
- Cold Start (seed)
Coding / AHE
Text cls. / FewShotAll
Workspace / ReAct
Engineering / ReAct
Show data table
| Benchmark | Full SIM | Harness Transfer (no SIM) | Problem-Only Memory | Cold Start (seed) |
|---|---|---|---|---|
| Coding / AHE | 21.82 | 18.18 | 20.61 | 19.39 |
| Text cls. / FewShotAll | 83.80 | 80.20 | 81.32 | 82.72 |
| Workspace / ReAct | 84.75 | 73.42 | 79.22 | 82.98 |
| Engineering / ReAct | 50.43 | 42.61 | 46.96 | 40.87 |
Source: Yu et al., arXiv 2611.18856, Table 6. Single run per condition.
Harness Transfer without memory finished below Cold Start in three of the four domains. Full SIM finished highest in all four, 3.60 to 11.33 points above harness-only continuation. The workspace result is the largest in the paper: both conditions started at 68.41, Full SIM reached 84.75 and Harness Transfer reached 73.42.

Can one harness serve several models?
A separate experiment on the text-classification target suite asked whether one harness can serve Grok 4.20 Reasoning, Claude Opus 5.5 and Gemini 3.8 Flash together. Averaged over the three models on held-out examples:
| Harness construction | Evolve | Held-out | All |
|---|---|---|---|
| B1: per-model harnesses (each model optimised separately) | 77.40 | 75.20 | 76.30 |
| B2: shared seed (no optimisation) | 72.36 | 73.28 | 72.82 |
| S1: sequential CRSI (Grok, then Gemini, then Opus) | 76.72 | 74.20 | 75.46 |
| S2: unified synthesis (feedback from all three models) | 78.92 | 75.24 | 77.08 |
| S3: harness evolved with Gemini 3.8 Flash only | 74.28 | 71.24 | 72.76 |
| S3: harness evolved with Grok 4.20 Reasoning only | 68.24 | 66.84 | 67.54 |
| S3: harness evolved with Claude Opus 5.5 only | 75.20 | 72.24 | 73.72 |
A single harness optimised on feedback from all three models matched separately optimised harnesses on held-out data (75.24 versus 75.20). A harness evolved on one model and reused for all three did worse: all three single-model harnesses (66.84 to 72.24 on held-out data) finished below the unoptimised shared seed's 73.28. Each procedure was run once, and the authors stress that small differences do not establish a ranking.
The Gemini Generation Chain, Including Gemini 4 Argon
The experiment most relevant to the "Google RSI" framing is a chain across four Gemini generations on held-out TB2.1: Gemini 2.5 Flash, 3.5 Flash, 3.8 Flash and Gemini 4 Argon. Fresh RSI optimises from the seed harness at each generation. CRSI adds SIM in the first generation and then passes the evolved harness and memory on to each new model.
Success rate on held-out TB2.1 across Gemini generations
Seed harness vs fresh optimisation vs continual optimisation with SIM carried forward. Higher is better.
- CRSI (harness + SIM carried forward)
- Fresh RSI (from seed)
- Seed harness
Gemini 2.5 Flash
Gemini 3.5 Flash
Gemini 3.8 Flash
Gemini 4 Argon
Show data table
| Benchmark | CRSI (harness + SIM carried forward) | Fresh RSI (from seed) | Seed harness |
|---|---|---|---|
| Gemini 2.5 Flash | 22.4% | 21.4% | 17.8% |
| Gemini 3.5 Flash | 76.8% | 73.3% | 70.2% |
| Gemini 3.8 Flash | 90.5% | 88.9% | 87.2% |
| Gemini 4 Argon | 94.8% | 95.6% | 89.7% |
Source: Yu et al., arXiv 2611.18856, Table 1. Scores to one decimal.
The first row (Gemini 2.5 Flash) only tests SIM within an initial run, because both procedures start from the same seed. The three later rows test transfer. Continuation won on Gemini 3.5 Flash (+3.5 points) and Gemini 3.8 Flash (+1.6) but finished 0.8 points below fresh optimisation on Gemini 4 Argon (94.8 versus 95.6). The authors report this in the paper's main table and repeat it on the project page under "Continuation can lose".
Why might the strongest model benefit least? The paper does not test an explanation, so any answer is speculation. Two plausible factors: at around 90% and above there is little headroom on TB2.1, and harness fixes for weaker models' failure modes (such as malformed tool calls) may matter less, or even get in the way, for a stronger one. The paper's case studies do note that "parser repairs depend on the policy model." Either way, the chain is one run per generation, and it does not show that carrying memory forward always helps as models improve.
For outside context, the paper notes that Google's published TB2.1 scores for Gemini 3.5 Flash and 3.8 Flash are 76.2 and 89.4, but these come from different evaluation settings and are not matched controls. It gives no external score for Gemini 4 Argon.
WorldofAI's video description also mentions "new Gemini 4 Helium and Krypton teasers". We could not find an official Google source for either name, and neither appears in the paper, so treat them as unconfirmed.
AI Revolution X covers Self-Improvement Memory as Google research that lets AI carry lessons across models and tasks, alongside the Gemini 4 Neon launch and other news.
Inside the Memory: The Completion-Gate Case
The appendix case studies show what SIM does in practice, and they are the best part of the paper for anyone who builds agents. The clearest one follows a single harness component from TB2.1 to TB4.
Source: stopping before the work is done
On a TB2.1 task to configure a git server, the agent set up the repository, hook and web server, misread an instruction, never created the required user account, tested everything with a different account, and declared the task complete. The seed Terminus-2 harness could not catch this, because its completion check simply asked the model to confirm its claim. Source optimisation diagnosed the root cause, recorded as P5, "premature completion without execution verification", and over three accepted rounds built an "execution gating interlock": a state machine that refuses completion when the previous turn had a parse error, when no command actually ran, or when a terminal error is visible. The file grew to 275 lines. Successful rollouts on the git task went from 1 to 5 out of 5, as did a second task on Fibonacci and square-root circuits. In the P5 record, four of six predicted fixes came true.
Target: feasible is not the same as good
On TB4, a photonic waveguide routing task exposed a new gap. The agent produced a valid routing, ran the task's own feasibility checker, saw it pass and stopped. None of the four rejection rules fired. But the score was a cost function, and a feasible solution can still be a poor one. With SIM, the proposer read P5, kept the gate and its rationale, opened a new entry P8 ("premature termination on feasible but suboptimal solutions") and added a check that warns the agent that passing constraints proves feasibility, not optimality. The component grew from 275 to 437 lines.
Notably, the paper is candid that both P8 attempts were accepted but neither fixed its two targeted tasks: zero of four predictions came true, and those failures stay in the record. Without SIM, the matched run edited the same gate four times, twice to fix completion deadlocks it had created, and its round-3 rationale wrongly attributed the inherited gate to its own first round. That last detail is the whole argument for SIM in miniature: without history, the optimiser did not know where its own code came from.
Does SIM help the agent keep its old skills?
A single-run trace (AHE seed) tracked TB2.1 source scores while optimising on TB4. From a common 90.22, Full SIM ended at 88.89, Problem-Only Memory at 88.44 and Harness Transfer at 87.56, having dipped to 86.67. Full SIM lost 3 successful rollouts out of 225, against 6 for Harness Transfer, while gaining far more on TB4 than Problem-Only Memory (6.67 versus 0.61 points).

Limitations: What the Evidence Does Not Show
The authors list most of these themselves, which is a good sign. Read together, they define how far the result can be stretched.
- Single runs outside coding. Only the coding study has independent repetitions. The six cross-dataset and four cross-model results are one complete optimisation run per condition. Five rollouts per task measure execution noise, not optimisation variance. The authors call these results descriptive.
- Matched rounds, not matched cost. All conditions get ten rounds and five candidates per round, but "token use and runtime can differ." Because SIM is read in full every round, it adds prompt tokens that grow as the record grows. The paper does not report the token or cost overhead.
- Compatible interfaces only. The evolved harness must still run in the new setting. "Arbitrary changes of task or interface are outside the evaluated scope."
- The optimiser does not improve itself. Planning and search procedures are fixed. That rules out the strongest form of RSI by design.
- Continuation can lose. One of ten coding pairs, and the Gemini 4 Argon step of the generation chain.
- No field-level ablation. SIM is tested as a complete procedure. We do not know whether predictions, rationale or provenance does most of the work.
- Judge and evaluator effects. Workspace scores rely on a Gemini 3.8 Flash judge, and the paper notes they "may also reflect biases of the LLM judge."
- Not peer-reviewed, no code. It is an arXiv preprint, and the project page says no public implementation is linked. Nobody outside the team can yet reproduce it.
- Small absolute scores in coding. The coding gains are on a TB4 setting where every condition stays below 25 out of 100.
There is also a safety angle that the paper raises briefly. "A self-modifying harness could satisfy an evaluator without solving the intended task." The authors kept held-out feedback away from the optimiser and used frozen verifiers or a fixed judge. As these loops become longer-running and more autonomous, that separation becomes a real security boundary, not just good experimental practice.
Where SIM Fits in Google's RSI Research
SIM is not a one-off. It is the latest in a run of 2026 papers from Google researchers and others on improving agents by editing the harness rather than the model:
- RRSI (Regularized Recursive Self-Improvement), from Google Cloud AI Research and partners, tackled overfitting: harness optimisers tend to memorise their test tasks. The Decoder reported on 04/10/2026 that it gained up to 14.1 points on training tasks and up to 4.7 on unseen benchmarks with a frozen model. SIM borrows RRSI's workspace and engineering environments and seed harnesses.
- Harness², an open-source Google Research framework covered in our Harness² explainer, lets an agent refine the harness around a frozen model without a ground-truth verifier. It shares the same premise as SIM: improve the layer around the model, not the weights.
- Meta-Harness and AHE (Agentic Harness Engineering) provide the basic optimisation loop and one of the coding seeds.
- Outside Google, Weco's AIDE² applies a similar outer loop to a research agent's scaffold code, and also stops short of the stage where the improver becomes a better improver.
Lead author Xin Yu also maintains a Harness RSI research atlas, a versioned dataset of reported harness changes and outcomes. Its 18/11/2026 update lists a bibliography of 347 papers and a v0.8.0 dataset of 170 records. The field is moving fast, and SIM's specific contribution is continuity: making optimisation survive the changes that real deployments go through.
What It Means for Agent Builders
You do not need Google's optimiser to use the main lesson. If you maintain an agent harness, whether by hand, with a coding agent, or with tools such as Antigravity Dynamic Workflows, the paper is a strong argument for treating harness changes like experiments.
- Log the why, not just the diff. For every prompt, tool or guard-rail change, record the failure it addresses, the tasks you expect it to fix (before you test), what actually happened, and which model and benchmark you tested on. That is the SIM schema, more or less.
- Keep the failures. SIM records accepted edits that missed their predictions. Those are often the most useful entries when conditions change.
- Re-test when you switch models. The cross-model results are a warning: a harness tuned for one model family started below the other family's plain seed in every domain. Do not assume your Claude-tuned agent will work better on Gemini, or the reverse.
- Do not assume an optimised harness is a better start. In the FewShotAll case, inherited optimisation without history did worse than starting fresh.
- Feed the history to whatever makes the next change. If a coding agent edits your harness, give it the changelog in context. The no-SIM run that misattributed its own inherited gate is a familiar failure for anyone who has watched an agent "fix" code it does not understand.
- Budget for the memory. Full-text memory is simple but grows. At some point you will need summarisation or retrieval, which the paper did not test.
- Keep a held-out set away from the optimiser. Otherwise you are measuring how well it games your tests.
For teams choosing tools rather than building them, our best AI coding agents comparison covers the harnesses most developers actually use.
The Bottom Line
Google has not achieved recursive self-improvement in the sense that should worry, or excite, anyone thinking about superintelligence. What a Google-led team has shown is that harness-level self-improvement works better across model and benchmark changes when the optimiser keeps a structured memory of why it made each change and what happened. The central result, +2.36 points in 9 of 10 paired coding runs with p = 0.003, is modest in size, clean in design and honestly reported, negative pair and Gemini 4 Argon shortfall included.
That is the real story, and it is a useful one. As agents move from model to model every few months, the knowledge locked up in their harnesses becomes a durable asset, and the reasons behind that knowledge turn out to be worth keeping too. The leap from "remembers why it changed its code" to "improves its own intelligence without limit" is one this paper does not make, and does not claim to.
Last updated: 20/11/2026. All figures are taken from arXiv 2611.18856v1 and its project page, and are author-reported. The paper is a preprint and has not been independently reproduced. We have not run the method ourselves.
Sources
- arXiv: Self-Improvement Memory Enables Continual Recursive Self-Improvement, Yu et al. (13/11/2026)
- arXiv HTML full text, v1 (Tables 1–7, figures and appendices)
- SIM project page: Self-Improvement Memory
- Hugging Face Papers: author post and discussion
- Harness RSI: evidence dataset and research atlas
- The Decoder: Google researchers find a way to keep self-improving AI agents from memorising their tests (RRSI, 04/10/2026)
- WorldofAI: Google ACHIEVED RSI?! (YouTube)
- AI Revolution X: Google Unleashes Gemini 4 Neon ... New RSI (YouTube)






