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

> Source: <https://explainx.ai/blog/google-self-improvement-memory-crsi-harness-optimization-2026?utm_source=rss&utm_medium=feed&utm_campaign=blog>
> Published: 2026-11-18 00:00:00+00:00

**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 the playbook "Designing agent systems": <https://wpnews.pro/playbooks/agent-architecture>

**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*](https://arxiv.org/abs/2611.18856?ref=explainx) (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](https://arxiv.org/abs/2503.18878?ref=explainx) 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](https://explainx.ai/blog/higher-scoring-coding-models-swe-bench-merge-rate-natural-experiment-2026)—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:

- [Together’s compiler-agent RSI for inference](https://explainx.ai/blog/together-compiler-agents-optimize-inference-1111-tps-minimax-1205-tps-deepseek-claimed-vs-verified-2026) optimizes**engine code** , not harness prompts—different loop, same vocabulary.
- [Anthropic’s RSP threshold updates](https://explainx.ai/blog/anthropic-rsp-ai-rd-threshold-met-s-1-amendment-2-november-2026) discuss**model** acceleration, while SIM is**harness** acceleration.
- [MIT weight-space programming](https://explainx.ai/blog/weight-space-programming-gpt-6-astra-edits-qwen3-5-0-8b-weights-math-7-9-to-48-1-mit-csail-2026) edits weights; SIM explicitly keeps weights fixed.

## 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](https://explainx.ai/blog/swe-cowork-coding-agents-digital-employees-benchmark-2026), 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](https://explainx.ai/blog/vals-ai-military-targeting-civilians-game-framing-claude-opus-5-5-2026) 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](https://explainx.ai/blog/raindrop-reasoning-agent-memory-tau2-bench-67-percent-2026).

## 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](https://explainx.ai/blog/google-gtig-sombermeme-claude-code-settings-backdoor-november-2026) 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 preserve**unsafe shortcuts** that scored well on evolve sets; keep held-out eval and human review ([Raindrop-style agent memory](https://explainx.ai/blog/raindrop-reasoning-agent-memory-tau2-bench-67-percent-2026) 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](https://explainx.ai/blog/together-compiler-agents-optimize-inference-1111-tps-minimax-1205-tps-deepseek-claimed-vs-verified-2026) more than [weight-space programming](https://explainx.ai/blog/weight-space-programming-gpt-6-astra-edits-qwen3-5-0-8b-weights-math-7-9-to-48-1-mit-csail-2026). When vendors say “self-improving,” ask whether tokens, harness files, or weights changed.

## Workshop tie-in for practitioners

Teams running [Claude Code workshops](https://explainx.ai/blog/top-claude-live-workshops-2026) 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** and**observed 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](https://explainx.ai/blog/forceharness-frozen-frontier-models-force-robot-harness-2026) 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.

## Related reading

*Claims follow [arXiv:2611.18856](https://arxiv.org/abs/2611.18856?ref=explainx) as published November 2026.*
