Self-Improving Loops
Three papers landed in November 2026, from Google, from Google Cloud and DeepMind with Penn State, and from Meta. They work on different problems: an agent harness that rewrites itself, a memory that lets improvement survive a change of model, and a factory that manufactures benchmarks. Underneath, all three are the same machine. This site explains that machine completely: what it is, what the evidence actually shows, where it breaks, and what to build with it.
The skeleton, in plain language
A loop edits an artifact. The artifact is code or configuration around a model: a harness, a memory file, a benchmark definition. The model's weights never change.
Each round starts from fresh context. The loop does not carry a long, decaying conversation. It re-reads its state from files at the start of every iteration, does one bounded step, and writes the state back.
State lives in files. Past attempts, scores, diagnoses, and predictions sit in structured files that any later round, or a human, can inspect. Nothing important exists only inside a model's memory of the conversation.
A frozen check the loop cannot game decides what survives. Something outside the loop's edit reach renders the verdict: a held-out test set in read-only storage, a set of quality anchors fixed before any run, a grader the loop is forbidden to touch. The proposer can be as creative as it likes. It cannot move the goalposts, because it cannot reach them.
That is the whole idea. Everything on this site is an elaboration: how each paper builds the machine, what breaks when a part is missing, and how to point the same machine at cybersecurity, where the checks happen to be unusually honest.
The three papers, one line each
- Harnesses That Improve Themselves (Shah and Kathrotia, Google, arXiv:2611.22299): a framework for agent harnesses that edit their own code one module at a time behind an acceptance gate. Its one small experiment (one run per method) put gated edits one task behind a full rewrite on 40 held-out tasks (40.0%, 16/40, versus 42.5%, 17/40): ahead in-domain (8/20 versus 7/20), behind on the cross-repository set (8/20 versus 10/20), at roughly a tenth of the runtime tokens per task.
- Self-Improvement Memory (Yu et al., Google Cloud AI, DeepMind, Penn State, arXiv:2611.18856): when the model or the benchmark changes, carry the record of past edits, their reasons, their pre-registered predictions, and their outcomes along with the edited artifact, because the artifact alone often starts below the plain seed.
- Benchmark Factory (Shahidi et al., Meta, arXiv:2611.18890): an agent loop that builds benchmarks from an organization's own merged code changes and validates them with label-free quality anchors, checks on known model orderings that need no per-task human labels.
A fourth paper, TRUST (arXiv:2611.10787), replaces the acceptance gate with a statistical one and measures how often a score-greedy gate accepts changes that are actually worse (45.59% in its experiments, abstract-level). It gets its own shorter page because it answers the question the other three leave open: how do you know the gate itself works?
Site map
Prerequisites (read these first if the vocabulary is new)
- The Loop: agents, harnesses, propose and evaluate, fresh context, state in files, gated versus ungated edits.
- Verifiers and Graders: what renders the verdict, RLVR, why the check must be frozen, necessary versus sufficient, Goodhart's law.
- Benchmarks: what a benchmark actually measures, discrimination versus realism, capability ordering, difficulty bands, contamination, live benchmarks.
- Two Spaces of Improvement: improving the weights versus improving everything around the model, and how the two compose.
The papers
- Paper 1: Harnesses That Improve Themselves
- Paper 2: Self-Improvement Memory
- Paper 3: Benchmark Factory
- The Fourth Member: TRUST
Synthesis and application
- The Complete Synthesis: the shared skeleton as one architecture, a comparison across the four papers, where they disagree, an evidence-strength table, the adversarial read, and the doctrine that falls out.
- The Cyber Version: why cyber is the natural home for this skeleton, and how it maps onto the cyber range and gym, Proof of Defense, the Orange threat-to-task pipeline, the LAB2 data factory, and the Divinity pipeline.
- The Build Book: seven buildable projects, with architecture, frozen checks, acceptance criteria, and a dependency order.
- Glossary: about thirty-five terms, each defined plainly and linked to where it is used.
- The Reading Path: the twenty prerequisite papers and systems, ordered as a curriculum.
Three reading paths
The 30-minute version
- This page.
- The Loop, for the vocabulary.
- The Complete Synthesis, for the architecture, the comparison table, and the evidence-strength table.
- The "in one breath" summary at the top of each paper page.
The complete version
- All four prerequisite pages, in order: The Loop, Verifiers and Graders, Benchmarks, Two Spaces.
- The three paper pages in order, then TRUST.
- The Complete Synthesis.
- The Cyber Version.
- The Reading Path, for everything underneath.
The builder's version
- Verifiers and Graders and Benchmarks, because every build stands or falls on its check.
- Paper 3: Benchmark Factory, because most of the seven builds are its direct descendants.
- The "adversarial read" section of the synthesis, because it lists the weaknesses a build inherits.
- The Cyber Version, practice section.
- The Build Book, in dependency order.
A note on evidence
Numbers on this site carry their conditions: sample sizes, which model, which split, how many runs, who ran the experiment. Claims are marked by kind, using six labels:
- Paper-reported (checked). Stated in one of the three main papers and checked against its full text. This is the default for every number on the three paper pages: the number is the paper's own, accurately transcribed, and not independently replicated.
- Abstract-level. Checked only against an arXiv abstract or listing. This covers TRUST, every reading-path entry, and the sidebar papers.
- Cited, not verified. A paper's characterization of someone else's work, such as Paper 1's survey table of other systems.
- Site arithmetic. Computed by this site from reported numbers, such as token ratios.
- Doctrine or speculation. The site's own inference or proposal, labeled where it appears.
- Program design. Statements about Brandon's programs, taken from the build book draft. Thresholds marked assumption there are starting values, not findings.
Reading coverage, stated precisely: Paper 1 and Paper 3 were read in full text. Paper 2 was read in its main text, Tables 1 to 3, Limitations, Ethics, and Appendix F in full; its Appendices B to E were skimmed, not read line by line, and the Paper 2 page flags that. TRUST was checked at abstract level only. The prerequisite entries were checked against their arXiv records.
An adversarial review panel was also run: one model (in Perplexity), in two threads, from one origin. The site uses its valid criticisms and names its errors, including a confident and false claim that Paper 1 reports no first-party numbers. Where a paper's own numbers undercut its headline, the site says so. That habit is, not coincidentally, the subject of the site.