AI Tools Review
Did Google Achieve RSI? Self-Improvement Memory

Insights

Did Google Achieve RSI? Self-Improvement Memory

AI Tools Review Editorial Team20 November 2026

    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.

    Diagram of the harness optimisation loop: evolve-set tasks feed an evaluator running a frozen policy; a proposer reads code and history and proposes k edits; a selector screens and verifies candidates; Self-Improvement Memory, holding root causes, selected edits, rationale, predicted and observed outcomes, and model, benchmark and round, is read by both proposer and selector and updated with the selected edit and outcome; the retained harness feeds the next round.
    The optimisation loop with SIM. The proposer and selector both read the memory (dashed arrows); after selection, the chosen edit and its measured outcome are written back. Held-out evaluation sits outside the loop. Source: Yu et al., Google, arXiv 2611.18856.

    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:

    FieldWhat it records
    what, filesThe edit and which harness files it touched
    predictedTasks the edit is expected to fix, written before evaluation
    fixed, missedWhich predictions came true after evaluation
    passed / totalSuccessful and total evolve-set trials for that attempt
    acceptedWhether the selector chose it, even if some predictions failed
    round, domainProvenance: 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.

    DomainSource benchmarkTarget benchmarkMetricSeed harnesses
    CodingTerminal-Bench 2.1 (89 tasks)Terminal-Bench 4 (66 tasks)pass@1AHE, Terminus-2
    Text classification3 datasets (412 examples)8 unseen datasets (1,000 examples)AccuracyNoMemory, FewShotAll
    Agentic workspaceHarvey LAB (160 tasks)JobBench + GDPval + APEX-Agents (765 tasks)Equal-weight meanReAct agent
    Engineering designEngDesign (67 tasks)Frontier-Eng (47 tasks)Pass rate / medal scoreReAct 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

    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
    Show data table
    BenchmarkContinue with SIMContinue without SIM
    Run 122.4220.61
    Run 219.3917.58
    Run 320.6120.00
    Run 423.6418.18
    Run 520.6118.79
    Run 623.6420.00
    Run 721.8220.00
    Run 819.3920.00
    Run 923.0318.18
    Run 1022.4220.00
    Mean21.7019.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.

    RunStartNo SIMSIMSIM minus No SIM
    118.1820.6122.42+1.81
    216.9717.5819.39+1.81
    317.5820.0020.61+0.61
    418.1818.1823.64+5.46
    517.5818.7920.61+1.82
    619.3920.0023.64+3.64
    718.7920.0021.82+1.82
    818.1820.0019.39−0.61
    919.3918.1823.03+4.85
    1019.3920.0022.42+2.42
    Mean18.3619.3321.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.

    Three-panel coding results chart. Panels (a) and (b) plot held-out Terminal-Bench 4 score by target RSI round for AHE and Terminus-2 seeds, with Full SIM reaching 24.85 and 21.82 and finishing above Cold Start, Harness Transfer and Problem-Only Memory. Panel (c) shows ten paired bars of SIM minus No SIM, nine positive and one negative at -0.61, with a dashed mean line at +2.36.
    Coding optimisation from TB2.1 to TB4. Top: held-out TB4 score after each target round for the AHE and Terminus-2 seeds. Bottom: the ten paired differences, with run 8 the single negative pair. Source: Yu et al., Google, arXiv 2611.18856.

    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

    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
    Show data table
    BenchmarkFull SIMHarness Transfer (no SIM)Problem-Only MemoryCold Start (seed)
    Coding / AHE24.8520.6118.7919.39
    Coding / Terminus-221.8219.3920.6119.39
    Text cls. / NoMemory73.6071.0073.4072.00
    Text cls. / FewShotAll77.9274.1275.5275.92
    Workspace / ReAct87.8985.0785.5482.98
    Engineering / ReAct46.9642.6142.6140.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).

    Six-panel grouped bar chart of held-out target scores before and after target RSI for Cold Start, Harness Transfer, Problem-Only Memory and Full SIM across coding (AHE and Terminus-2), text classification (NoMemory and FewShotAll), workspace and engineering. Full SIM has the highest after-score in each panel: 24.85, 21.82, 73.60, 77.92, 87.89 and 46.96.
    Cross-dataset CRSI: held-out target scores before (open bars) and after (filled bars) target optimisation. The three transfer conditions share the source-evolved harness; Cold Start uses the seed. Axis limits vary by domain. Source: Yu et al., Google, arXiv 2611.18856.

    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

    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
    Show data table
    BenchmarkFull SIMHarness Transfer (no SIM)Problem-Only MemoryCold Start (seed)
    Coding / AHE21.8218.1820.6119.39
    Text cls. / FewShotAll83.8080.2081.3282.72
    Workspace / ReAct84.7573.4279.2282.98
    Engineering / ReAct50.4342.6146.9640.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.

    Four-panel grouped bar chart of cross-model results from Claude Opus 5.5 to Gemini 3.8 Flash. Transfer conditions start below Cold Start in each domain; Full SIM finishes highest: 21.82 coding, 83.80 text classification, 84.75 workspace and 50.43 engineering.
    Cross-model CRSI from Claude Opus 5.5 to Gemini 3.8 Flash. Open bars show scores before Gemini's target optimisation; filled bars after. Source: Yu et al., Google, arXiv 2611.18856.

    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 constructionEvolveHeld-outAll
    B1: per-model harnesses (each model optimised separately)77.4075.2076.30
    B2: shared seed (no optimisation)72.3673.2872.82
    S1: sequential CRSI (Grok, then Gemini, then Opus)76.7274.2075.46
    S2: unified synthesis (feedback from all three models)78.9275.2477.08
    S3: harness evolved with Gemini 3.8 Flash only74.2871.2472.76
    S3: harness evolved with Grok 4.20 Reasoning only68.2466.8467.54
    S3: harness evolved with Claude Opus 5.5 only75.2072.2473.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

    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%
    Show data table
    BenchmarkCRSI (harness + SIM carried forward)Fresh RSI (from seed)Seed harness
    Gemini 2.5 Flash22.4%21.4%17.8%
    Gemini 3.5 Flash76.8%73.3%70.2%
    Gemini 3.8 Flash90.5%88.9%87.2%
    Gemini 4 Argon94.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).

    Line chart of held-out TB2.1 score by target RSI round. Full SIM, Problem-Only Memory and Harness Transfer start at 90.22; Full SIM ends near 88.9, Problem-Only near 88.4, Harness Transfer near 87.6 after dipping to about 86.7; Cold Start stays near 84 to 86.
    Source retention during target optimisation: held-out TB2.1 score of the harness retained after each TB4 round (AHE seed, one run per condition). Source: Yu et al., Google, arXiv 2611.18856.

    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.

    1. 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.
    2. Keep the failures. SIM records accepted edits that missed their predictions. Those are often the most useful entries when conditions change.
    3. 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.
    4. Do not assume an optimised harness is a better start. In the FewShotAll case, inherited optimisation without history did worse than starting fresh.
    5. 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.
    6. 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.
    7. 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

    Frequently Asked Questions

    Did Google achieve recursive self-improvement (RSI)?
    Not in the sense most people mean. The 13/11/2026 preprint from Google Cloud AI, Google DeepMind and Penn State shows harness-level recursive self-improvement: an LLM optimiser repeatedly rewrites the code, prompts and tools wrapped around a frozen model, and a new memory lets that process continue when the model or benchmark changes. No model weights are updated, the optimiser itself is not redesigned, and the authors state that the study does not establish unbounded self-improvement.
    What is Self-Improvement Memory (SIM)?
    Self-Improvement Memory is a structured record kept by the harness optimiser, not by the task-solving model. It groups accepted harness edits by the recurring problem they address and stores each edit's rationale, the tasks it was predicted to fix, what actually happened, and the setting (domain, benchmark, model and round) in which it was tested. Both the proposer and the selector read the full record every round, and new attempts are appended rather than overwriting history.
    How much does Self-Improvement Memory improve results?
    In the main controlled test, ten independent coding runs moved from Terminal-Bench 2.1 to Terminal-Bench 4. Continuing with SIM beat continuing without it in 9 of 10 pairs, by an average of 2.36 points (21.70 versus 19.33 mean final score, 95% confidence interval 1.05 to 3.68, p = 0.003). In single-run comparisons across four domains, Full SIM finished highest in all six cross-dataset and all four Claude Opus 5.5 to Gemini 3.8 Flash settings.
    What is continual recursive self-improvement (CRSI)?
    Continual recursive self-improvement is the paper's name for continuing an automated harness-optimisation run after something changes: either the benchmark changes while the model stays fixed (cross-dataset), or the model changes while the benchmark and split stay fixed (cross-model). The harness must keep a compatible executable interface. CRSI asks whether the experience gained in the first run can help the second, instead of starting again from scratch.
    Can I use Self-Improvement Memory in my own agent today?
    Not as a download. The project page states that no public implementation is linked. The idea is simple enough to copy, though: keep a structured changelog for your agent harness that records the problem, the change, the predicted fix, the measured outcome and the model and benchmark it was tested on, and give that log to whoever, or whatever, makes the next round of changes. Expect extra token cost, because SIM is read in full every round.
    AI Tools Review Editorial Team

    AI Tools Review Editorial Team Expert verified

    Our editorial team consists of veteran AI researchers, software engineers, and industry analysts. We spend hundreds of hours benchmarking frontier models natively to provide you with objective, actionable intelligence on agentic AI capabilities and cybersecurity landscapes.