Prerequisites I: The Loop

Everything in the three papers is built from six ideas. None of them is exotic. The contribution of the November papers is assembling them into one machine and showing, with measurements, which parts bear the load. This page defines each idea plainly. The companion pages cover verifiers and graders, benchmarks, and the two spaces of improvement.

Agents

An agent is a model in a loop. The model reads a state, chooses an action (run a command, edit a file, call a tool), observes the result, and repeats until a stopping rule fires. A single model call answers a question. An agent does a job: it acts, checks what happened, and adjusts. Coding agents write and test software this way. Attack agents probe a defended system this way. The papers on this site are about improving the machinery that runs the loop, not the model inside it.

Harnesses

The harness is all the runtime software around a frozen model. It has four parts, following the decomposition in Paper 1:

  1. Context and state: what the model is shown each turn, how old observations are compacted or masked, how working memory is separated from longer-term memory.
  2. Agent control: turn budgets, loop detection, when to plan versus when to execute, when to delegate to a subagent.
  3. Action interface: how model output becomes real actions (shell commands, file edits), how raw output is parsed and truncated before the model sees it, which tool schemas are loaded.
  4. Verification and recovery: what runs before the agent is allowed to stop: tests, linters, checks that route failures back for another attempt.

The premise of the whole research line, established most clearly by SWE-agent in 2024 (see the reading path), is that harness quality is a first-order performance variable. The same model, in a better harness, solves materially more tasks. If that is true, then improving the harness is a real form of improvement, and it can be automated.

Propose and evaluate

Every self-improving loop separates two jobs that a naive design merges:

The separation matters because the two jobs have opposite failure modes. A proposer should be imaginative and a little reckless. An evaluator should be boring and incorruptible. When one component does both, the recklessness wins: the system grades its own homework. All three papers enforce the separation structurally. In Paper 3, the meta-agent that builds benchmarks cannot edit the grader or the expected model ordering. In Paper 2, held-out evaluation sits outside the loop entirely, and only evolve-set (development) feedback ever reaches the proposer.

One caution carries through the whole site. Separation keeps the proposer away from the verdict. It does not prove the evaluator is any good. None of the papers ran an adversarial test of its own gate or selector, a gap the synthesis names as an open problem.

Fresh context

Each iteration of the loop starts with an empty context window. The agent performing the step reads its instructions and its state from files, does one bounded piece of work, writes results back to files, and exits.

This sounds like a limitation. It is a discipline. A long-running conversation accumulates drift: early assumptions go stale, failed approaches linger as suggestions, the context fills with the debris of earlier rounds. Fresh context plus file state means the loop's memory is exactly what is written down, no more and no less, and a human can read all of it. Paper 3 states this explicitly and names the pattern the "Ralph" loop. Paper 2 is the same idea one level up: its memory is a structured file that the proposer and selector read in full at the start of every round.

State in files

The corollary of fresh context: anything the loop needs to remember must be in a file. Scores, traces, diagnoses, edit histories, predictions. Files have three properties a context window does not. They persist across runs and across model changes. They can be inspected, diffed, and audited by a human. And they can be placed outside the loop's edit reach, which is how you build a check the loop cannot game: put the grader and the logs in read-only storage, and the loop can read its verdict but never rewrite it.

The strongest version of this idea is Paper 2's memory entry: for each attempted edit, the root cause it addressed, the modification and its rationale, the outcome predicted before evaluation, the outcome actually observed, and the provenance (which model, which benchmark, which round). State in files, kept honestly, is what turns a loop from a slot machine into an experiment log.

Gated versus ungated edits

An ungated loop applies whatever change the proposer produces, or keeps whichever candidate scores best on the same data the proposer was looking at. A gated loop interposes an acceptance test the candidate must pass on data or checks the proposer does not control: non-regression on a held-out split, a token budget, a set of pre-registered anchors.

The November papers are, in large part, a measurement of the difference. Paper 1's single experiment (paper-reported, one run per method) compared its gated method against an ungated full-harness rewrite on 40 held-out tasks:

At these sizes one task is 5 points on a split and 2.5 points combined, so none of these gaps separates the methods on accuracy. What does separate them: the rewrite cost 451.6k tokens per task against the gated method's 46.7k (runtime tokens, roughly ten times; site arithmetic gives 9.7), it fell from 42.5% to 30.0% when moved unchanged to a stronger model, and it left 5.0% of cross-repository runs (1 of 20) ending without verification, against 0.0% for the gated harness.

The gated method's defining moment was a rejection: a plausible edit, raising the turn limit, that helped on development tasks was killed before it shipped because validation accuracy dropped and the token cap was breached. The validation split was 8 tasks, so the size of that drop is coarse (one task is 12.5 points). TRUST measures the stakes from the other side: in its experiments (abstract-level), a score-greedy gate accepted updates that were actually inferior 45.59% of the time. That number describes the score-greedy gate as implemented in TRUST's study, not every gate.

A tiny worked example

A coding agent keeps failing tasks by declaring itself done with an empty or untested change.

The example is a composite of two papers. The edit and its gate are Paper 1's accepted verify.py change, almost exactly, and the rejected turn-limit edit in the same run is the worked example of why the gate exists. The written prediction and the memory record come from Paper 2, which is the paper that pre-registers predictions and keeps failures on file. Paper 1 does not record predictions; putting the two together is the site's doctrine, developed in the synthesis.