cd /news/artificial-intelligence/self-improvement-memory-googles-crsi… · home › topics › artificial-intelligence › article
[ARTICLE · art-171763] src=explainx.ai ↗ pub= topic=artificial-intelligence verified=true sentiment=↑ positive

Self-Improvement Memory: Google’s CRSI Harness Optimization Paper

Google researchers proposed Self-Improvement Memory (SIM) in arXiv paper 2611.18856, "Self-Improvement Memory Enables Continual Recursive Self-Improvement," to let agents keep improving their harness — prompts, tools and context rules — without losing the rationale behind earlier edits when the benchmark or model changes. The paper defines Continual Recursive Self-Improvement (CRSI) and reports that full SIM beats harness-only and root-cause-only continuation, with a mean gain of +2.36 points over harness-only across 10 paired coding runs (p=0.003). The authors document harness transfer brittleness, noting an Opus-evolved harness started below the seed harness on Gemini in their workspace experiment (68.41 vs 73.89).

recommendation

Log each harness edit's rationale, predicted vs observed score and evaluation context, and append to existing problem entries rather than resetting, so the optimizer can keep, revise or delete edits when the model or benchmark changes.

more in playbook: Designing agent systems
by read8 min views3 publishedNov 18, 2026
Self-Improvement Memory: Google’s CRSI Harness Optimization Paper
Image: Explainx (auto-discovered)

Google researchers proposed Self-Improvement Memory (SIM) so agents can keep improving their harness—prompts, tools, context rules—without forgetting why earlier edits worked when the benchmark or model changes. The paper Self-Improvement Memory Enables Continual Recursive Self-Improvement (arXiv 2611.18856) defines Continual Recursive Self-Improvement (CRSI) and reports consistent gains over continuing optimization with the harness alone.

For builders, the headline is practical: harness transfer is brittle. An Opus-evolved harness can start below the seed harness on Gemini in the authors’ workspace experiment (68.41 vs 73.89 in their figure). SIM is meant to supply the missing rationale and outcomes so the optimizer knows what to keep, revise, or delete.

TL;DR #

Piece What the paper says
Object optimized Executable harness around a fixed policy model
SIM stores Problem groups, edit rationale, predicted vs observed scores, context
CRSI settings Cross-dataset (same model) and cross-model (same benchmark split)
Main result Full SIM beats harness-only and root-cause-only continuation
Coding delta Mean +2.36 points vs harness-only on 10 paired runs (p=0.003)
Code release Not linked on arXiv page when we checked

Why harness-only transfer fails #

Modern agents depend on two artifacts: weights inside the policy model and the harness that manages context, tools, and execution. Manual harness tuning is slow; recent recursive self-improvement (RSI) work automates propose-evaluate-select loops (Meta-Harness lineage cited in the paper).

The authors argue RSI usually assumes a fixed model and benchmark. Real teams break that assumption constantly:

Transition What breaks
New model version Mechanisms tuned for Opus interact differently on Gemini
New task suite A completion gate that checked command success may need optimality checks

Without memory, the target optimizer sees code diffs but not why a gate existed or what failure it fixed—so it may repeat failed edits or strip useful guards.

Product teams feel the same pain when they copy a CLAUDE.md from an Opus project to a Gemini project and watch pass rates crater. Benchmark leaders publish harness recipes—see the higher-scoring models vs merge-rate experiment—but those recipes are rarely portable without the failure logs that produced them. SIM is the paper’s proposal for machine-readable failure logs at harness-edit granularity.

What SIM records #

SIM groups edits by recurring harness problems and logs:

  • Rationale for the proposed change
  • Predicted and observed outcomes after evaluation
  • Evaluation context on the evolve set

Both the proposer and selector read SIM each round. New attempts append to existing problem entries instead of resetting history.

That differs from storing only candidate harnesses (HarnessBank-style grouping) or free-text notes: SIM ties problems → modifications → measured results in one structure the LLM harness engineer can query.

Structured notebook beside an agent node, illustrating harness edit history the optimizer can query

CRSI problem setup #

The paper formalizes harness RSI with rounds of propose, screen, execute, and select (Equation 1 in the PDF). CRSI resumes from the source harness after optimization in the source setting and continues in a target setting.

Mode Change Fixed
Cross-dataset CRSI Benchmark task suite Policy model
Cross-model CRSI Policy model Benchmark split

Target improvement is final minus starting score on held-out evaluation—standard harness optimization hygiene with evolve vs eval splits.

Test bench framing for evolve versus held-out harness evaluation splits

Experimental claims to read carefully #

The abstract highlights four domains and six cross-dataset plus four Opus→Gemini comparisons where Full SIM tops ablations without memory or with root causes only.

The coding headline is statistical: across ten independent source runs, paired continuations with SIM improve 9 of 10 runs, mean +2.36 points over harness-only continuation, p=0.003.

Those numbers are authors’ benchmarks, not a guarantee on your repository. They do support the intuition that memory of the improvement process matters—not only the final harness artifact.

Connect this to industry narratives without overclaiming:

Meta-Harness lineage and what SIM adds #

The related-work section places SIM beside Meta-Harness, AHE, and HarnessBank-style memory. Those systems already store candidates or edit graphs. SIM’s twist is to keep problem labels stable across CRSI: when the benchmark shifts from “did the shell command run?” to “is the solution optimal?”, the optimizer can query SIM for the original bug class instead of guessing from the final Python file alone.

For readers who track agent evals, that is closer to maintaining a regression suite for harness code than maintaining prompts. If your team runs SWE-CoWork-style benches, imagine each flaky harness gate becoming a SIM entry with pass/fail history whenever you promote a new base model.

Interpreting the Opus→Gemini regression example #

The paper’s workspace figure is a cautionary tale: an evolved harness that scored well under Anthropic’s policy model can underperform the seed harness on Gemini despite identical tasks. That is not a surprise to anyone who has swapped models on a brittle tool-calling loop, but it is useful evidence because it is quantified rather than anecdotal.

Builders should replicate a miniature version before production promotion:

  1. Freeze your evolve split and held-out split.
  2. Run harness RSI once on model A.
  3. Resume CRSI on model B with harness-only vs SIM-enabled optimizers.
  4. Compare held-out scores, not evolve-set peaks.

If you lack Google’s automations, you can still manually append a JSONL file of {problem, edit, outcome} beside your harness repo—SIM’s idea without the full selector stack. Lightweight scaffold holding a harness module while the policy model stays fixed

Safety and misuse angles #

Memory of successful hacks is double-edged. A harness edit that overfits the evolve set (for example, hard-coding test identifiers) will look brilliant in SIM until held-out evaluation collapses. The paper leans on standard evolve vs eval splits, but product teams should add red-team tasks the evolve set never sees—similar to Vals.ai military targeting critiques about eval framing.

Storing rationale also creates data-retention questions: SIM logs may include stack traces, API errors, or user data snippets from evolve tasks. Any future open-source drop will need scrubbing policies like those discussed in enterprise agent memory posts.

How this relates to harness tooling you can use today #

Until SIM ships in a product, builders still improve harnesses manually or via open tools:

Approach Memory of edits?
Git history on CLAUDE.md / skills Diffs only
| [SoduWork plugins](https://explainx.ai/blog/soduwork-self-hosted-multi-harness-agent-workspace-2026) | Versioned workflows with review | 
| [LoopForge SOPs](https://explainx.ai/blog/tencent-loopforge-self-hosted-sop-coding-agents-claude-codex-2026) | Human gates, not automatic harness search | 

SIM is the research direction that could eventually sit under those control planes if Google productizes CRSI.

Authors and affiliations #

The PDF lists Google Cloud AI and Google DeepMind authors alongside Penn State (Lingzhou Xue). Footnotes note Xin Yu interned at Google. That placement matters for credibility and for where a future open release might appear—similar to other Google GTIG security research paths.

What to watch next #

  1. Code or HarnessBank integration — if authors release SIM logs, try replaying CRSI on your own benchmark split before swapping models in production.
  2. Cross-model tables — reproduce the Opus→Gemini regression on an internal task before trusting a transferred harness from a vendor eval.
  3. Safety — richer harness memory can also preserveunsafe shortcuts that scored well on evolve sets; keep held-out eval and human review (Raindrop-style agent memory discusses related RSI risks).

FAQ tie-in: is this “real” recursive self-improvement? #

Readers often conflate harness RSI with weight RSI. This paper keeps the policy checkpoint fixed while an outer loop edits orchestration code. That matches Together’s compiler-agent loop more than weight-space programming. When vendors say “self-improving,” ask whether tokens, harness files, or weights changed.

Workshop tie-in for practitioners #

Teams running Claude Code workshops already document why each harness tweak worked. SIM formalizes that habit for automated selectors. The homework after reading the paper: start a harness changelog with measured outcomes before your next model upgrade.

Implementation checklist (manual SIM today) #

You can approximate SIM without Google’s stack:

Step Action
1 Tag each harness edit with a problem id (tool timeouts, wrong file paths, format drift)
2 Log predicted fix andobserved metric on evolve and held-out splits
3 When swapping models, feed the log to the human reviewer before accepting inherited gates
4 Archive rejected edits so the optimizer does not re-propose them

This mirrors how ForceHarness keeps robot policies stable while models churn—different domain, same portability problem.

Paper authors also cite continual learning concerns—catastrophic forgetting when new edits erase old fixes. SIM’s grouped problem entries are their mitigation: append new attempts under the same problem id instead of wiping history. That design choice is why the selector can reject a flashy harness rewrite that violates an earlier constraint logged under the same heading.

If Google releases code, expect it beside Cloud AI agent tooling rather than as a consumer feature. Until then, treat arXiv 2611.18856 as the authoritative description of CRSI and SIM behavior, and reproduce key tables yourself before changing production harnesses.

Claims follow arXiv:2611.18856 as published November 2026.

── more in #artificial-intelligence 4 stories · sorted by recency
── more on @google 3 stories trending now
sponsored brought to you by zahid.host 4,200+ EU-deployed projects
reading about agents? ship yours in a single git push.

Run your AI side-project on zahid.host

EU-based hosting, git-push deploys, automatic HTTPS, no cold starts. Free tier with a custom domain — perfect for shipping the agent you just read about.

$git push zahid main
→ Live at https://your-agent.zahid.host ✓
Get free account → Pricing
from €0/mo · no card required
LIVE [news/self-improvement-mem…] indexed:0 read:8min 2026-11-18 · —