Google's Self-Improvement Memory Shows Agent Harnesses Transfer Better When Edit Reasons Are Logged
Gemini 3.8 Flash scored 84.75 with the edit log and 73.42 without it; a fresh start reached 82.98

A Google Cloud AI, Google DeepMind and Penn State preprint is circulating this week under Chinese-language headlines about new Google progress on recursive self-improvement, a framing that invites readings the paper never makes: that Google has achieved recursive self-improvement internally and that new Gemini models now inherit the experience of old ones. What the paper actually shows is narrower and more useful for anyone building agents. When the model underneath an agent changes, the optimizer that keeps tuning the agent's surrounding code does better if it inherits a structured log of why each earlier edit was made, not just the edited code. No model weights change anywhere in the study. The authors posted it to arXiv as a preprint that has not been peer reviewed.
The paper, arXiv 2611.18856, proposes Self-Improvement Memory, or SIM, for a setting its authors call Continual Recursive Self-Improvement, or CRSI. arXiv lists version 1 as submitted on November 13, and attention spiked on November 18 and 19 as explainx and Chinese-language outlet Zhidx covered it. Google shipped Gemini 4 Neon on November 18, six days after Gemini 4 Hydrogen, which makes it tempting to connect the two. The model cards do not support that link.
The most valuable takeaway for practitioners is the portability problem the paper measures. A harness tuned for one model is a depreciating asset, and the thing that makes it transferable is the record of reasoning behind its edits.
The Paper Tests Harness Optimization, Not Model Self-Improvement
A harness is everything wrapped around a language model that turns it into an agent: system prompts, tool definitions, context management, execution flow, stopping rules and memory. In the paper's setup the policy model, the one that actually solves tasks, is frozen. A separate optimizer, itself a language model, repeatedly proposes edits to the harness code, tests candidates on a set of tasks, and keeps the best. The authors call this recursive self-improvement at the agent-system level, a usage that a recent survey of the field says conflates different ambitions, from bounded self-refinement to open-ended self-improvement.
CRSI asks what happens next. A team optimizes a harness on one benchmark or model, the "source" stage, and then the benchmark or the model changes. The optimizer resumes from the final source harness at the "target" stage. The paper tests two variants: cross-dataset CRSI, where the benchmark changes and the policy stays fixed, and cross-model CRSI, where the policy changes and the benchmark stays fixed.
The experiments span four domains. In coding, the source is Terminal-Bench 2.1 with 89 tasks and the target is Terminal-Bench 4 with 66 tasks. In text classification, the optimizer moves from three datasets, including LawBench and USPTO-50k, to eight unseen ones such as Banking77. In agentic workspace tasks, it moves from Harvey LAB to an equal-weight mean of JobBench, GDPval and APEX-Agents. In engineering design, it moves from EngDesign to Frontier-Eng. Per the paper's benchmark table, each benchmark is split into roughly equal evolve and held-out halves, and every reported score comes from the held-out half.
Gemini 3.8 Flash is the policy in cross-dataset CRSI and the target policy in the cross-model study, where Claude Opus 5.5 is the source policy. It also serves as the optimizer's proposer and selector in the main comparisons, including when Opus is the model executing the tasks. That detail matters because it is easy to read the setup as Gemini inheriting Claude's memory. The inherited material is a harness built to serve Opus and a log of edits, not anything Claude remembers.
A Harness Evolved for Opus Scored Below Gemini's Own Starting Point
The motivating problem is measurable. When the Opus-evolved harness is first run with Gemini, the paper reports that it scores below Gemini's seed harness in every domain, by 0.60 points in text classification up to 5.48 in workspace tasks. FourWeekMBA's summary of the preprint reports the same range. As the authors frame it, inheriting finished code can be worse than starting over, because the new optimizer sees rules, interceptors and prompt fragments with no record of what each one was meant to fix. It may delete a patch for a real bug as redundant, or retry an idea that was already shown to fail.
The paper's case study makes this concrete with a failure mode called premature completion, where an agent declares a task finished without doing the work. In the source run on Terminal-Bench 2.1, the seed harness only asked the model to confirm its own claim of completion. In one failing rollout, the agent never created a required user account, tested with a different one, and still reported success. Over three accepted rounds, the source optimizer built an execution gate that grew to 275 lines and gained four rejection paths. Two tasks that had succeeded in one of five rollouts went to five of five.
At the target stage, the two conditions diverged. Without SIM, the optimizer edited the same gate four times, twice to repair completion deadlocks it had introduced, and at one point attributed to itself a gate that was inherited. With SIM, the optimizer read why the gate existed, kept it, and extended it so the agent compares its score against theoretical bounds before finishing. The authors report the gate grew from 275 to 437 lines in the target harness.
How Self-Improvement Memory Records an Edit and Its Outcome
SIM is a structured file rather than a chat history. Edits are grouped under a recurring root-cause hypothesis, with "premature completion" as the paper's example. When the optimizer diagnoses a new root cause, the file gains an entry. When the diagnosis matches an existing one, the new attempt is appended. Each attempt records the round, a description of the edit, the files changed, the tasks the optimizer predicted it would fix before evaluation, the tasks it actually fixed or missed afterward, the number of passing trials, and the domain, benchmark and model on which it ran.
The predicted-versus-observed pairing is the design choice that separates SIM from a plain changelog. Because predictions are logged before evaluation, the next optimizer can see how well its predecessor understood the problem, and can weight that reasoning accordingly. The log also keeps failures. Only the selected candidate at each round is recorded, but that includes edits that regressed or failed to fix their predicted tasks. In the case study, one entry on premature termination records two attempts that were both selected and neither of which fixed any of its four predicted tasks.
The optimizer reads the entire log in its system prompt, with no retrieval or truncation, and the selector that ranks candidates reads the same record. The authors instruct the optimizer to treat entries as prior experience rather than fact: check the domain, benchmark and model, reassess edits after a change, and give task-specific evidence less weight when both the benchmark and the model have changed. Whether a new diagnosis matches an old root cause is decided by the proposer model itself, with identical text merged deterministically. Every condition in the comparisons uses ten rounds and five candidates per round. The paper says a coding round takes about four hours, including 1.7 hours for evaluation, which implies a sequential ten-round run on the order of forty hours by this publication's arithmetic.
One design consequence deserves attention. Because the full log goes into the prompt untruncated, it grows with every accepted edit, and the paper's ten-round runs do not test what happens when a harness has hundreds of entries. At that scale a team would need summarization or retrieval, which is exactly the part of the design the authors chose to leave out, so the approach's context-length ceiling is an open engineering question rather than a measured result. Compared with its neighbors, SIM trades generality for transparency: RRSI regularizes harness evolution, ReHarness revises stored lessons while the agent runs, and SIM keeps an auditable ledger that a human reviewer can read line by line.
This is what "reflection memory" looks like when it is aimed at the optimizer instead of the task-solving agent. Earlier work in the Reflexion line stores verbal lessons in an episodic memory buffer for the agent. SIM stores lessons about the agent's code for whichever model edits it next. A separate paper from Meta, MIT and Yale, ReHarness, tackles a neighboring flaw: memory that only flows forward and cannot correct wrong lessons.
Read more: Meta and MIT fix agent memory that cannot self-correct
Benchmark Results: Memory Beats Code-Only Transfer, but a Fresh Start Is Competitive
The paper compares four conditions with matched rounds and candidate budgets. Cold Start runs from the original seed harness. Harness Transfer inherits the evolved harness only. Problem-Only Memory inherits the harness plus root-cause labels without edits or outcomes. Full SIM inherits the harness and the complete log. All figures below are the authors' own held-out results.
In the cross-model Opus-to-Gemini study, the final scores in the paper's Table 6 were as follows.
Domain Cold Start Harness Transfer Problem-Only Full SIM Workspace 82.98 73.42 79.22 84.75 Coding (AHE seed) 19.39 18.18 20.61 21.82 Text classification 82.72 80.20 81.32 83.80 Engineering design 40.87 42.61 46.96 50.43
The headline circulating online, a jump from 68.41 to 84.75 in workspace tasks, is arithmetically correct, a gain of 16.34 points. But 68.41 is the starting score of the inherited harness on Gemini, and the fairer comparisons are the final scores of the other conditions. Full SIM beat code-only transfer by 11.33 points, which is the largest gap in the paper. It beat a cold start by 1.77 points in workspace, 2.43 in coding, 1.08 in text and 9.56 in engineering, by this publication's subtraction. In three of four domains, inheriting the evolved harness without memory finished below simply starting over from the seed. That is the strongest evidence in the paper that code alone is a liability across a model swap.
The coding result is the only one backed by repeated runs. The authors ran ten independent source optimizations on Terminal-Bench 2.1 and, from each resulting harness, started two ten-round Terminal-Bench 4 runs, one inheriting SIM and one without. SIM won nine of ten pairs, with a mean paired advantage of 2.36 points, a 95 percent confidence interval of 1.05 to 3.68 and p = 0.003. The one loss was 0.61 points. The mean final scores were 21.70 with SIM against 19.33 without.
Scale is worth keeping in view. The paper's benchmark table lists 33 held-out Terminal-Bench 4 tasks scored over five rollouts each, or 165 attempts, so a 2.36-point mean gap equals roughly four additional successful rollouts per run, by this publication's arithmetic. That is statistically detectable across ten paired runs, and it is also small in absolute terms. The authors state that every domain other than coding used a single run per condition, so the margins in workspace, text and engineering are not accompanied by variance estimates. The workspace tasks are scored with Gemini 3.8 Flash as the judge, the same model serving as policy, proposer and selector in the main comparisons, and the paper's ethics statement acknowledges that workspace scores may reflect biases of the LLM judge.
Continual Self-Improvement Did Not Compound Across Four Gemini Generations
Retellings of SIM describe it as enabling compound growth, with each generation building on the last. The paper's generation chain on Terminal-Bench 2.1 does not show that. It compares fresh optimization against continued optimization for four successive Gemini policies. For Gemini 2.5 Flash, continuation scored 22.4 against 21.4 for fresh. For 3.5 Flash it was 76.8 against 73.3, a 3.5-point gain. For 3.8 Flash it was 90.5 against 88.9. For Gemini 4 Argon it was 94.8 against 95.6, so inherited experience finished 0.8 points behind a fresh run.
The increments are +1.0, +3.5, +1.6 and −0.8, by this publication's subtraction. That pattern is consistent with a technique that helps when there is headroom and a compatible interface, and does not guarantee improvement on every handoff. The authors do not claim otherwise, and a footnote on scale is in order: the later generations score between the high 80s and the mid 90s on this benchmark split, where there is little left to gain.
Recursive Self-Improvement Here Means Harness Edits Under a Fixed Evaluator
The term "recursive self-improvement" carries heavy baggage, so precision helps. In this literature it usually means a loop where a system proposes a change to itself, evaluates it against a fixed external scorer, retains what works, and uses the modified system in the next round. The Darwin Gödel Machine, a self-modifying coding agent, lifted SWE-bench performance from 20.0 percent to 50.0 percent and Polyglot from 14.2 percent to 30.7 percent in its authors' tests. The RRSI paper, posted September 21, proposed regularizing harness evolution and reports gains of up to 4.3 points on five out-of-distribution benchmarks with 30 percent fewer policy tokens than unregularized evolution. SIM extends that line to the continuation problem.
Skeptical evidence exists in the same literature. The benchmark paper SelfImprove-Bench reports that the evolutionary gains of existing RSI methods are inconsistent across levels of generalization. A separate study, Rethinking the Evaluation of Harness Evolution for Agents, found on Terminal-Bench 2.1 that automatic harness evolution does not consistently outperform simple test-time scaling under matched feedback and inference budgets, and that evolved harnesses generalized only marginally to held-out tasks. SIM's results are one more data point in a field where gains depend heavily on what is held constant.
Under the distinction Jeff Dean drew at Stanford on October 28, recursive self-improvement requires a system that also gets better at improving itself, not only one that produces better products. In SIM, the optimizer's own planning and search procedures are held fixed, and the paper lists adapting them as future work. What improves is the harness and the log that accompanies it. That makes SIM a memory for an optimization pipeline, a meaningful engineering advance, though one that stops short of the strict RSI loop. A different kind of claim sits in the system card for OpenAI's GPT-6.2 Astra, which OpenAI says is its first externally released model to meet the High threshold for AI self-improvement under its Preparedness Framework.
Read more: Jeff Dean on why self-improvement loops cannot run infinitely fast
Nothing in the Paper Links SIM to Gemini 4 Neon or Hydrogen
The causal story told online runs: Google builds self-improving memory, so Google ships models faster. The evidence points elsewhere. Neon's model card states the model is adapted from Gemini 4 Carbon and defers to Carbon's card for architecture, training data and hardware, and Hydrogen's card says the same. Google announced Argon on September 30. It opened a limited Carbon preview on October 28 and general availability on November 10. Hydrogen followed on November 12 and Neon on November 18, which makes four models in about seven weeks by this publication's count. A shared base model offers a more direct explanation for that cadence than an optimizer memory.
The paper itself reads as research, not product disclosure. According to Zhidx, the first author, Xin Yu, is a Penn State PhD student who did the work during a Google internship, and the paper's ethics statement says the experiments use existing publicly available benchmarks. FourWeekMBA's review of the preprint found no Google statement that it uses the method in a product. The policy model used in the paper, Gemini 3.8 Flash, was replaced by Hydrogen across Google's products on November 12, the day before the paper's arXiv submission date.
What Teams Running Agents Can Take From This Now
The practical lesson survives the hype. Models turn over quickly. The policy model in this paper was already one product generation old by the time it circulated. Any team that tunes prompts, tools and guardrails for one model faces the same exposure the paper measures, and a harness handed to a new model, or a new optimizer, without its reasoning can perform below the starting seed.
The cheap version of SIM requires no research code. Record each change with its hypothesized root cause, the tasks it was expected to fix, the tasks it actually fixed, and the model and dataset it was tested on. Keep the failures. Then give the next model, or the next engineer, that record along with the code. The paper's controlled evidence for this is strongest in coding, where ten repeated runs back it, and thinner elsewhere.
The compatibility requirement is the main boundary. The study covers settings in which the inherited harness keeps a compatible executable interface. When a new model needs a different tool format or different context management, the log may mislead as much as it guides, which is why the authors tell the optimizer to discount task-specific evidence when both model and benchmark change.
What Replication and Release Would Need to Show Next
The results are the authors' own, on a preprint that has not been peer reviewed, with repeated runs in one domain only. The arXiv page lists no code repository, and FourWeekMBA reports no independent replication or peer review. Three things would change the picture. An independent group reproducing the nine-of-ten coding result on other policy models would test whether the effect belongs to SIM or to this particular Gemini and Terminal-Bench setup. Longer transition sequences, where more than one model swap occurs, would test the compounding claim that retellings make and the generation chain does not yet support. And evidence that any lab uses a memory like this to build its production agent stack, rather than to study the question, would make the Google-internal-RSI claim a factual one. Until then, the defensible reading is a measured improvement in how an optimizer survives a model swap: the log of why a change was made turned out to matter more than the change, and the model underneath never learned anything.



