What We Talk About When We Talk About RSI

Papert said "People can only construct new knowledge on the basis of what they already have; one can only learn what one is already prepared to construct. "

A harness may work the same way.

When Meta-Harness came out, RSI was not a name yet. We were building a nested-agent setup: could an upper agent rewrite a lower one, and did that nesting have some kind of scaling law. Once models crossed a threshold, letting them keep rewriting their own structure felt like the obvious, exciting next step.

Wind the clock back to the start of this year. AlphaEvolve wired evolutionary search to an LLM: sample from a program archive, let the model edit code, evaluate, write the good candidates back. The archive keeps diversity with MAP-Elites; the model guides search with its prior. The model's input is still curated.

each round t:
  1. database.sample()
       draw parent + inspirations from MAP-Elites
  2. prompt_sampler.build(parent, inspirations)
       problem statement + source + scores + eval feedback → one curated prompt
  3. llm.generate(prompt) → diff
       apply_diff(parent, diff) → child
  4. evaluator.execute(child) → scores
  5. database.add(child, scores)
       archive by MAP-Elites, go to the next round

Meta-Harness is simpler: open the full history, open the edit permissions. Agent, you're free. A coding agent can read the whole repo and change it, so of course a frontier model in a coding-agent loop can read every revision history and rewrite itself. You read more, you learn more.

1. Read scaling?

Does the proposer actually read more? In our experiments we mounted the full history for the proposer and instrumented the loop: every round, log which files it opened.

Setting:

substrate  : MemGPT-style memory harness
inner model: Qwen3-8B
benchmark  : LoCoMo / LongMemEval
proposer   : Codex / Kimi
rounds     : 30
scale      : 21 unfiltered runs
interface  : all prior-iteration directories mounted
probe      : read path of every file

By round 30 it can nominally see all source, scores, and diagnostic traces from the previous 29 rounds. Under You read more, you learn more, the archive grows, so the read set should grow.

It does not. Mounted directories rise from 2.2 per round to 23, a tenfold increase; files the proposer actually opens stay around 18; coverage falls from 82% to 14%. Directories actually read plateau around 3.

Mounted history grows while the number of inspected directories stays nearly flat — Mounted prior-iteration directories grow from 2.2 to 23, while directories actually inspected plateau around three. Mean across 21 unfiltered runs.

Read-file calls and tool-output bytes are flat from the early window to the late window. Under free exploration, what the model reads converges; it does not grow without bound.

Reads also hug recent rounds. A young iteration is 4 to 7 times more likely to be opened than an old one. The one exception is the global score table: 95% of late rounds open it, while the diagnostic traces that explain those scores sit next to it, untouched. Keep the result, throw away the cause.

Read probability is concentrated along the recent edge of the iteration history — Probability that proposal round t reads prior iteration i. Inspection concentrates along the recent edge; the older interior of the archive is rarely touched.

There are two readings. If the model can already pick the most valuable files out of a sea of them, it obviously does not need to read more. We ran a probe: randomly select 3 directories, force attention into those three, and ask whether optimizing from a small history actually limits iteration. The scores barely moved. So the model does not seem to find the most valuable information on its own. It may also mean that, in free exploration, the model's own prior bias matters as much as the history.

A three-slot aperture selects both old and recent iterations from the full history — Random-3 exposes only three prior iterations. Once an old iteration enters this small aperture, it is read regardless of its distance from the current round.

2. Action scaling?

The seduction of RSI is that we no longer have to build every paradigm by hand and push it slowly. Enough compute and time, and it scales. In that picture the structure is simple: Trace, Feedback, Propose, Evaluate. One gold standard, and the model iterates everything. Take RL's brute-force miracle and drop it into an open-ended domain. As long as the model is strong enough, it can write Claude Code from a simple agent loop.

As long as the model is strong enough.

But Und das Gesetz nur kann uns Freiheit geben. With no constraint, there seems to be no exploration either.

The second experiment switched substrates: candidates are free-form .mjs agent modules, every node runs the same model, edit permissions fully open. Under the picture above, that is free exploration — structure should grow out of the seed on its own.

Setting:

substrate : vendored harness optimizer
candidate : free-form .mjs agent module
domains   : RealMath / BCPlus / AppWorld / SWE-Pro
proposer  : Codex / Kimi
question  : how much of the organizational-form space do edits occupy

We ran a control on how the search space affects the proposer.

Vanilla  : strip every mention of decomposition, hooks, parallel structure
Designed : we set the slots — node prompt, contract, topology, rails, glue code

Once the slots are there, edits start falling into them. Sixteen runs of ten rounds each: 43/80 Vanilla candidates carry a hook, 74/80 in Designed; topology edits roughly double; in seven of eight cells a run occupies a wider set of organizational forms. Codex produced only single-node candidates across forty Vanilla attempts; after Designed, multi-node candidates start to appear on RealMath and SWE-Pro.

On AppWorld, topology is still zero; hooks just go from 0/10 to 10/10. The cheap slots get filled. The expensive ones stay empty most of the time.

Proposal adoption moves from bare and name-only interfaces toward scaffolded structural slots — Pooled proposal adoption across twelve frozen replay states. Explicit scaffolds shift edits toward structural forms, hooks, and output contracts.

3. Performance scaling?

If the harness optimizer cannot really explore, what kind of capability gain is it producing?

We took every task where the seed failed and the champion flipped it (48 tasks across four domains, 78 failing rollouts) and labeled each seed failure:

A · mechanical, submission : the correct answer is already in the transcript,
                             but never submitted / cut off before submit /
                             packed into a container the grader rejects
B · mechanical, resource   : derivation still progressing, then maxTurns / token
                             budget / a tool-call loop kills it
C · genuine error          : submitted through the normal path, wrong value or plan

Mechanical failures dominate RealMath and BCPlus but not AppWorld or SWE-Pro — Failure attribution for seed rollouts later flipped by a champion. Mechanical submission or resource failures account for 60% of RealMath and 84% of BCPlus failures.

In the two domains with the largest training gains, mechanical failures are the majority.

# fold submitted parts into the gold container type, no model in the loop
gold is Tuple      -> Tuple-join the submitted parts
gold is FiniteSet  -> wrap each part in a Tuple, then insert
otherwise          -> leave it

Change the grader's normalization and the seed itself goes from .473 to .547 on the train split.

Contract recovery mechanisms transfer to held-out tasks while task-keyed mechanisms do not — Held-out score delta for each train-selected champion. Contract-recovery mechanisms transfer; task-keyed and generic interventions do not separate reliably from the seed.

Those fixes transfer to held-out, of course. How much does that mean? The RSI people imagine is not a grader adapter.

4. Self-harness is good, but not interesting

A continually improving harness looks more like a self-iterating edge-case repairer. Done well enough, the engineering gains are real and measurable. Is that actually self-evolving?

At least for now, it may not be that interesting.

Note. Proposers were Codex (gpt-5.5) and Kimi (kimi-k2.6). The inner model was Qwen3-8B and deepseek-v4-flash. Behavior can differ across model versions.