Self-play for language models — what is implementable, 2026-10-18

Design input for the port’s self-play lane. Read with docs/research/2026-10-15-agentic-post-training.md (the earlier sweep: SEED 2607.14777, anchored self-play 2607.03523, EGGROLL 2511.16652, VH-GPO 2610.14000, RetireOPD 2609.20784 — built on here, not re-found), docs/architecture/post-training.md (SFT→RLVR→self-evolve; the “distill” step is dead by owner decision), and port/src/dormouse/post/ (the live lane).

Verification method (ADR-0018 rule 1). Every ID was resolved through the arXiv MCP: search_papers returned it and get_abstract returned title+authors+abstract, read in full for every row marked (A). Four were read as full text via download_paper → read_paper_section (HTML endpoint), marked (F): 2609.30063, 2608.19197, 2605.22217, 2610.22029. Snippet-only reads (title + ~280-char abstract) are (S). No HTTP 429 occurred; no fallback to arxiv.org/abs/ pages was needed. Numbers are as the authors report them; I reproduced nothing.

Evidence marks: (A) abstract read · (F) full text read · (S) snippet only · (X) SPECULATION, my inference, no source.

---

TL;DR — six verdicts

1. The newest credible thing is round-level inheritance gating, not task selection. 2610.22029 (10-15, (F)) audits R-Zero/Agent0/Skill Self-Play: 42-52% of native Agent0/R-Zero admissions leave the frontier under independent responses, 60 of 96 Skill-SP updates have nonpositive correct-target NLL gain. HeirCommit (freeze the successor, compare against root on fresh probes, inherit or retain) cuts harmful accepted updates by 68-83%; EvoHeir raises the base model’s math average 7.9-30.1% over four backbones. This is the thing to build.
2. The gate beats the reward. 2605.22217 ((F), controlled, with a deterministic-DSL twin): every gate-off configuration collapses regardless of reward design; every gate-on configuration learns. The gate is “executes deterministically, same output twice”. Cheaper than every reward fix in the 2026 literature, and it is the binding constraint.
3. The only byte-native self-play loop found is 2609.30063 ((F), 09-24): a generator proposes programs for a universal Turing machine, the machine emits byte sequences (vocab 256, random init), the learner does next-byte CE, the generator gets a preconditioned gradient-alignment reward. Zero-shot loss scales as a power law in compute across text/images/music/DNA — in bits per byte, our own metric.
4. Anchoring has three independent 2026 shapes, all cheap: a frozen previous-iteration model (2610.09856, +2.5% math / +2.8% general over Agent0), a running-average reference (2606.22688), and a flat-top difficulty band on the task’s solver win rate (2608.19197, band [0.4, 0.6]). Our 10-15 anchor (2607.03523) is the first kind; the band is the one we lack.
5. Self-rewarding / LLM-judge self-play is measured broken, not merely suspect. 2607.05904 ((A)): on GSM8K with Qwen3, self-play drives the judge’s pass rate 0.72 → 0.94 while true accuracy stays 0.20 (3 seeds); the fix that works is a judge that commits an answer first (false positives 0.719 → 0.012). At 57M active the judge is the network being trained.
6. Build order: (i) determinism gate + difficulty band on the existing tasks.py/verifiers.py loop; (ii) HeirCommit round gating + experience archive; (iii) byte-level generator/learner self-play as a pretraining lane, only after (i)-(ii) show a measurable probe-set gain.

---

1. Ranked table — self-play candidates, 2026-10 state

Ranked by (data-lean bet × verifiability × cost) for a weak byte-level base, no teacher, no human data, verifiable domains, one GPU. LOC are (X) estimates for the port’s style, not measurements.

#	method	ID (how verified)	loop mechanism	teacher / human data?	measured gain + scale	fit for us
1	HeirCommit + EvoHeir (2610.22029, 10-15)	(F) abs+intro	explore → screen (freeze successor) → recover (repair failures from current+archived references, keep successes) → confirm on fresh probes → commit or retain root; archive keeps experience either way	none — needs a fresh probe set (ours: a held-out task seed, synthetic)	−68-83% harmful accepted updates at equal acceptance rate; EvoHeir +7.9-30.1% math avg over 4 backbones, +5.7 math pts / 10 rounds vs R-Zero peaking at round 8; beats Agent0 on 45/48 benchmark-backbone pairs; recovery +1.93 pp over direct FT on the same 64 references	HIGH — model-agnostic, one frozen copy of a 57M-active net, plugs into any loop
2	Determinism data gate (2605.22217, 05-21)	(F) §3.3, §4.1	proposer emits tasks; gate admits only tasks that execute deterministically across two runs; solver trains from a recent-biased pool; ε = admitted fraction of failed tasks	none	gate-on learns on all 3 eval sets (CRUXEval-O/I, HumanEval+/MBPP+); gate-off collapses on all 3 under every reward variant incl. a grounded one; intrinsic-grounded gap saturates ≈1.0 in ~200 steps when off	HIGH — ~70-100 LOC on verifiers.py; our code verifier already runs the program, add the second run
3	Byte-level generator/learner self-play (2609.30063, 09-24)	(F) §3-§4	generator proposes UTM programs (pool = fresh ∪ mutated ∪ replay) → machine emits byte sequences → learner takes CE steps → generator takes a GRPO step on a preconditioned gradient-alignment reward, KL to the Solomonoff prior, plus reward-weighted SFT	none	zero-shot power law L(C)=E+AC^-α in bits/byte on text/images/music/DNA; 34.36B-token budget, ctx 4096, K seeds ensembled	MEDIUM-HIGH — the only byte-native loop; costs a ~100-LOC interpreter and a JVP per program per round
4	AnchorLoop (2610.09856, 10-07)	(A)	frozen previous-iteration Executor reused on both sides: cross-reference advantage for the executor (current vs historical majority answers), agreement reference for the curriculum	none	+2.5% math, +2.8% general over Agent0 across 13 benchmarks; keeps effective-advantage variance higher; fixes group-relative advantage vanishing under full consensus	HIGH — that is exactly our crr_advantage hole (train_steps.py:47-50: an all-pass or all-empty group carries no signal)
5	GMAE (2609.36750, 09-29)	(A)	marginalize each response’s reward over possible group contexts instead of one realization; expected advantages	none	8 benchmarks × 4 base models; “stable learning, low extra cost”	HIGH, cheap — ~60-100 LOC beside crr_advantage
6	R-Diverse (2602.13103, 02-13)	(A)	Challenger–Solver + MAP (persistent memory bank penalizes cross-iteration recycling) + SAM (diversity by reasoning skills, not surface form)	none	10 math/general benchmarks; sustains gains over more iterations than R-Zero	HIGH as a monitor — the bank doubles as our dedup store
7	SGS (2604.20209, 04-22)	(A)	three roles: Solver, Conjecturer, Guide scoring synthetic problems by relevance to unsolved target problems and naturalness, against Conjecturer collapse	needs unsolved target problems (an anchor set)	Lean4: 7B after 200 rounds solves more problems than a 671B pass@4; beats the strongest RL baseline’s asymptotic solve rate in <80 rounds	MEDIUM — the Guide role is the anti-collapse piece
8	CompassPlay (2609.32228, 09-26)	(A)	proposer rewarded by gradient alignment of its task’s solver loss with reference tasks; first-order learning-progress proxy, no extra solver training	a small external reference set	Qwen2.5-Coder-7B: +1.5 pp in-domain coding, +2.7 pp OOD math over AZR’s difficulty reward; Lean4: 150-iteration coverage with 40% fewer GPU-hours	MEDIUM-HIGH — the reference set is synthesizable by us
9	SPADE (2608.19197, 08-19)	(F) §5, §7.1	one model, two roles: Environment Designer writes executable Gym reset()/step() envs and a privileged hint; Reasoning Agent plays with and without the hint; designer reward = 0.6·flat-top band [0.4,0.6] + 0.4·floored hint-regret; corpus grounding + environment memory	none (corpus grounding load-bearing)	30B-A3B: suite avg 58.3 = +8.1 over base, +5.3 over the strongest fixed-env baseline; ACEBench-Agent +13.9, BFCL-v4 multi-turn +5.7 (+10.3 at 4B), τ²-bench +3.6; 400 steps	MEDIUM — the loop ports, the numbers do not (30B); code-as-environment exceeds our 3-template tasks.py
10	LURE (2608.21871, 08-22)	(A)	pursuit–evasion: an LLM evader positions tasks along the environment’s difficulty axis; capture-frontier reward peaks when the solver captures on exactly half the rollouts; round-anchored KL	none	3 verifiable reasoning environments × 3 backbones; stronger aggregate OOD zero-shot accuracy than all trained baselines on 9 held-out benchmarks	MEDIUM — the half-capture rule is a 1-line band filter
11	SOAR (2601.18778, 01-26)	(A)	meta-RL teacher proposes problems, rewarded by the student’s actual improvement on a subset of hard problems (grounded, not intrinsic)	none	hardest math subsets (0/128 initial success); grounded rewards beat intrinsic learnability rewards; question well-posedness matters more than solution correctness	MEDIUM — bilevel meta-RL is the expensive half; the finding is the cheap lesson
12	R-Zero / AZR (2508.05004 / 2505.03335)	(A) both	Challenger–Solver co-evolution (R-Zero); one model proposes code-reasoning tasks, a code executor validates and verifies (AZR)	none	R-Zero: Qwen3-4B-Base +6.49 math, +7.54 general; AZR: SOTA among zero-setting models	HIGH as the baseline to beat — AZR’s executor is our verifiers.py
13	Skill Self-Play (2607.22529, 07-24)	(A)	proposer + solver + dynamic skill controller; skills give verifiable execution, routing gives open-ended variety	none	tool-use and reasoning benchmarks; code public	LOW — (X) a natural-language skill library at 57M active is unproven, and its retirement failure mode is unpoliceable
14	Explorer-Zero (2610.19868, 10-14)	(A) in the 10-15 sweep	proposer constructs tasks and records intermediate/final env states as verifiable targets; partial credit; alternating proposer/solver	none	30B agent 59.67% AppWorld vs 62.65% for RL on human tasks	MEDIUM — task+verifier synthesis in one loop; 30B scale

---

2. Top-3 expanded — the loop, not the idea

2.1 HeirCommit + EvoHeir (2610.22029) — the round gate

Generates: nothing new. It wraps whatever generator we already run (a proposer, or a mutation of tasks.py). That is why it is #1: it composes with every other row. One round, per the paper’s §1 and Figure 1:

1. Explore — run the round’s proposer/solver loop → a candidate successor M′ plus the round’s verified tasks and solutions.
2. Screen — compare M′ against the current model (the root) on fresh probes neither proposer nor solver has seen. The paper’s argument: reusing selection evidence to accept a branch pays a union bound over branches; fresh confirmation removes it.
3. Recover (EvoHeir) — repair M′’s failures from current and archived reference solutions while preserving its successes. References from 8 of 10 donors weaker than the current model still improved the recipient.
4. Confirm — commit M′ only if the post-absorption state beats root on the fresh probes; else retain root.
5. Archive — qualified experience enters regardless of the parameter decision (“parameter inheritance can stop without discarding material that helps a later recipient”); rejected-round experience adds +0.66 pp beyond committed-round history.

What stops collapse: a rejection test on the state, not the task — harmful commits −68-83% at equal acceptance rate. The archive stops the loop discarding learning when the model is rejected.

Cost (X): one frozen copy (57M active — trivial), a held-out probe set (build_tasks("code", probe_seed), never trained), a probe-eval per round, a JSONL archive. The expensive part is honest statistics (§6).

2.2 Determinism gate + difficulty band (2605.22217 + 2608.19197 + 2608.21871)

Generates: the proposer — in our lane, a mutation operator over tasks.py’s three templates (constants, docstring, test calls) first; a template-writing policy only if mutation works.

Filters, in order: (1) executability + determinism (2605.22217’s F_ε) — run the proposed task through the verifier harness twice, admit only on identical output; set ε = 0. (2) Difficulty band (2608.19197’s flat-top anchor, band [0.4, 0.6] solver win rate; equivalently 2608.21871’s half-capture rule) — our plan’s “frontier 70% (pass@k 30-60%)” with a measured shape. (3) Diversity (2602.13103) — a persistent memory bank penalizes tasks that recycle earlier rounds; at our scale (X) exact-duplicate and constant-difference detection is enough for v1.

Trains: the solver on admitted tasks (our CRR/advantage path); the proposer only if it is a policy — 2608.19197 uses per-role advantage normalization, a delayed designer update with truncated importance sampling, asymmetric clipping (0.2/0.28); 2609.32228 replaces the band with gradient alignment.

What stops collapse: the gate (gate-off collapses under every reward, including a grounded one), the band (difficulty regulation), the bank (recycling). Watch the paper’s counter-intuitive coupling, the Grounded Proposer Paradox: a proposer with ground-truth access collapses faster when paired with a self-consistency solver, by concentrating training on clean tasks that form the fastest path to a spurious self-consistent attractor. Do not hand the proposer the answers.

2.3 Byte-level generator/learner self-play (2609.30063) — the pretraining lane

Generates: programs. Both models are Llama-arch transformers from random init with byte-level tokenization, vocab 256 — the port’s vocabulary. A Brainf*ck-like universal Turing machine executes each program with a random input tape; the output bytes are the training data (programs prefixed by byte S, outputs by byte O).

1. Sample N programs; build the pool fresh ∪ mutated(high-reward past programs) ∪ replay(earlier rounds).
2. Execute each → output byte sequences.
3. Learner: one gradient step on standard next-byte CE, averaged over the pool.
4. Generator: a GRPO batch-level policy-gradient step on r_i = |⟨∇_θ L(y_i;θ), P_e ⊙ δθ_e⟩|, where δθ_e = θ_{⌊e/2⌋} − θ_e is the learner’s parameter movement over a growing lookback window and P_e is the diagonal AdamW preconditioner. Mastered programs give ~zero gradient; unlearnable structure gives misaligned gradient; high reward = not yet mastered and congruent with recent progress — a frontier signal with no external reward. KL-regularized to the Solomonoff prior g_0(x) = |A|^{-ℓ(x)}; sequence-level importance ratio clipped to e^{±20}; plus reward-weighted SFT (expert iteration, λ=1.0) against generator forgetting.
5. Repeat: 34.36B tokens max, context 4096, K seeds ensembled.

The paper explicitly rejects difficulty-based rewards — “a program can be made arbitrarily difficult without containing useful structure, for example by injecting random bytes into an otherwise predictable sequence”. Collapse is bounded by the KL to the prior, the mutation+replay pool, and expert iteration.

Cost (X): small interpreter; the reward needs a JVP (torch.func.jvp) per program per round. Our Rust trainer is launch-bound (AGENTS §3.1: mean GPU utilisation 13.3%), so many small JVPs suit the Python port, not the trainer.

---

3. Our implementation sketch

All of it in port/src/dormouse/post/, reusing what exists: tasks.build_tasks, verifiers.verify, rollouts.rollout (byte-budgeted), train_steps.crr_advantage, and train/sft.py’s render / sft_loss / sft_train (train/sft.py:399, :586, :609) as the training seam. No new heavy dependency.

file	what it adds	LOC (X)
post/gate.py	admit(task, solver) -> bool: execute twice, require identical verifier output; epsilon leak (default 0, COUNTED when non-zero); returns a GateVerdict	70-100
post/propose.py	proposer: deterministic mutation of tasks.py templates + persistent dedup bank; propose(cls, seed, round, n) -> list[Task]	150-220
post/selfplay.py	round orchestrator: propose → gate → band → G solver rollouts/task → verify → advantage → sft_train step → freeze successor → fresh-probe confirm → commit/retain	250-350
post/archive.py	JSONL store (task, verified_solution, round, win_rate, kept) + recovery selection	80-120
post/train_steps.py (edit)	add anchor_relative_advantage(group, anchor_group) (2610.09856) and gmae_advantage(groups) (2609.36750) beside crr_advantage	+60-100

Total ≈ 610-890 LOC (X).

First pre-registered experiment (arms written down before the run; ADR-0002 “a tie deletes the mechanism”):

• Polygon: 9.2M small, code class only (the exec verifier is deterministic and cheap), 3 seeds per arm, one GPU, one heavy thing at a time.
• Arms. A — control: masked-CE SFT on the seed task set for the same number of learner steps, no proposer, no self-play. B — gated self-play: proposer + gate.py (ε=0) + difficulty band + CRR/group advantage, inheriting every round (R-Zero-shaped). C — B + inheritance gate: adds archive.py and the HeirCommit fresh-probe confirm/retain, plus EvoHeir-style recovery.
• Held fixed: learner gradient steps, total rollout count, task-generator seed, byte budget, wall-clock budget. Probe set: build_tasks("code", seed=probe_seed), 128 tasks, never trained on, evaluated every round.
• Metrics: primary = verifier pass rate on the probe seed, reported as correct@budget(256 B) (the owner’s byte-thrift contract); secondary = BPB on eval_tail at the port’s declared window; monitors = cross-round duplicate rate (cheap MAP) and the within-input-entropy / cross-input-MI pair from the 10-15 sweep’s collapse checklist.
• Pre-registered rule: C > B > A on probe pass rate beyond the control’s own seed spread, or the mechanism is deleted. B ≥ C ⇒ drop HeirCommit. A ≥ B ⇒ the loop earns nothing at 9.2M; stop the lane and say so.

Byte-level note. Every method here is tokenizer-agnostic except those whose reward is per token (per-token logprobs, token-level KL, div_gate-style divergence, 2605.07725 from the 10-15 sweep). At byte level those must be re-defined per byte, and byte sequences are 3-4× longer than token sequences, so a per-position signal costs 3-4× more. The two shapes that survive unchanged: per-sequence CE (2609.30063) and verifier pass/fail over a byte-budgeted rollout (rollouts.py). Our metric being BPB is a coincidence in our favour — 2609.30063’s own reported quantity is bits per byte.

---

4. Explicit rejections

rejected	why
Self-rewarding / LLM-judge self-play (2401.10020, 2605.09959 G-Zero, 2608.26582 J-Zero, 2603.09206 MM-Zero, 2604.20051)	2607.05904 ((A)): judge pass 0.72 → 0.94 at true accuracy 0.20 (GSM8K, Qwen3, 3 seeds); errors transfer across judge families, a 3-judge ensemble still accepts 55%; 2607.07436 ((S)) shows a biased judge silently disables skill retirement. At 57M active the judge is the trained network. Revisit only with a frozen, externally-validated judge — and note 2607.05904’s cheap fix (judge commits first: FP 0.719 → 0.012).
SPIN family (2401.01335, 2601.08198, 2512.07175, 2607.19354)	Needs a human-annotated SFT seed as the “real” half of the pair, and optimises a preference objective, not a verifiable reward. Wrong shape for a verifier-first lane.
Unanchored adversarial / competitive self-play (2607.03523, 2608.01559)	2607.03523: unanchored generator–fixer self-play drifts to hard-but-unrealistic bugs and degrades on human-authored ones. 2608.01559 ((S)): controlled negative result — the competitive component gave no gain on legal reasoning.
Debate / multi-agent discussion as the training signal	No 2026 source found with a measured verifiable-reward gain from LM debate self-play. Nearest: 2606.30571 ((S), attractor states in multi-turn model–model conversations) and 2601.13566 ((S), theory of debate/bootstrap as coherence optimisation). No measured gain ⇒ no build.
Skill libraries / procedural memory (2607.22529, 2610.14515, 2605.19576, 2607.12790)	All LLM-agent scale. At 57M active a natural-language skill store is (X) unproven, and library drift is a silent failure mode (2605.19576) whose only known guard is an unbiased judge we cannot field. Defer.
Population-based multi-adapter self-play (2605.16727 PopuLoRA)	LoRA teachers/students on a shared frozen base; our model trains from scratch on one GPU, so a population multiplies VRAM and wall-clock for an LLM-scale benefit.
Chess / driving / game self-play (2609.37447, 2610.20866, 2609.21617, 2610.14883, 2610.13995)	Off-domain for code/math post-training. 2609.37447 is a useful efficiency datapoint (6.32M params, one 8-GPU node, 2.5 days) that transfers to nothing here.
Multimodal / safety self-play (2609.36224 MATE, 2610.15449, 2606.09701, 2610.05346)	Out of scope (vision, red-teaming).

---

5. VERIFIED (sourced)

• Classics, IDs correct (all (A)): SPIN = 2401.01335 (self-play fine-tuning; the LLM discriminates its own previous-iteration responses from human-annotated ones; optimum iff the policy matches the target distribution) · Self-Rewarding LMs = 2401.10020 (LLM-as-a-Judge supplies its own rewards during Iterative DPO; Llama-2-70B, 3 iterations, beats Claude 2 / Gemini Pro / GPT-4-0613 on AlpacaEval 2.0) · Absolute Zero / AZR = 2505.03335 (one model proposes code-reasoning tasks; a code executor validates them and verifies answers) · R-Zero = 2508.05004 (Challenger + Solver co-evolving; Qwen3-4B-Base +6.49 math, +7.54 general).
• 2026 “Zero” successors to AZR ((S) unless noted): G-Zero 2605.09959 (verifier-free, open-ended), J-Zero 2608.26582 (Challenger–Solver–Judge), MM-Zero 2603.09206 (VLM), Tool-R0 2602.21320 (tool learning), Explorer-Zero 2610.19868 ((A) in the 10-15 sweep). No 2026 paper titled “Absolute Zero” exists in this sweep — ti:"Absolute Zero" AND abs:"self-play" returned 0 results, consistent with the 10-15 sweep’s honest gap.
• Selection-to-update gap numbers (2610.22029, (F)): 42-52% of native Agent0/R-Zero admissions leave the frontier under independent responses; 60/96 Skill-SP updates have nonpositive correct-target NLL gain; HeirCommit −68-83% harmful commits; EvoHeir +7.9-30.1% math average over four backbones; +5.7 math pts / ten rounds; 45/48 benchmark-backbone pairs beat Agent0; recovery +1.93 pp over direct FT on the same 64 references; rejected-round experience +0.66 pp.
• The gate is the binding constraint (2605.22217, (F)): every gate-off configuration collapses, every gate-on learns, across reward variants including a self-consistency reward with no ground truth; the Grounded Proposer Paradox; the two-stage phase transition in ε; the deterministic-DSL twin that isolates the mechanism.
• Byte-level self-play exists and is one paper (2609.30063, (F)): 256-byte vocab, byte sequences from a universal machine, learner CE, generator RL on a preconditioned gradient-alignment reward with a growing lookback, Solomonoff KL, expert iteration, 34.36B-token budget, zero-shot power-law scaling in bits/byte on text/images/music/DNA.
• SPADE’s loop and numbers (2608.19197, (F)): code-as-environment reset()/step(), hint-based regret r_D(e) = r̄_A(e|h) − r̄_A(e), designer reward 0.6·band + 0.4·floored regret, per-role advantage normalization, delayed designer update with truncated IS, asymmetric clipping 0.2/0.28, corpus grounding required against the “invisible leash” collapse; 30B-A3B suite avg 58.3 (+5.3 over the strongest fixed-env baseline), ACEBench-Agent +13.9, BFCL-v4 multi-turn +5.7 (+10.3 at 4B), τ²-bench +3.6.
• Anti-drift / anti-collapse levers with measured support: previous-iteration anchor (2610.09856: +2.5%/+2.8% over Agent0) · running-average reference (2606.22688) · flat-top band and half-capture (2608.19197, 2608.21871) · memory-bank + skill-aware diversity (2602.13103) · grounded-over-intrinsic curriculum reward (2601.18778) · gradient-alignment proposer reward (2609.32228) · group-context marginalization (2609.36750) · determinism gate (2605.22217).
• Judge-based self-reward measured broken (2607.05904, (A)): 0.72 → 0.94 judge pass at 0.20 true accuracy; FP 0.719 → 0.012 with a committing judge.
• Self-training on plain self-sampled text, no verifier exists and works only under a compatibility condition (2605.31126, (A): same-lineage transfer beats stronger-but-different sources; benchmark utility preserved while verbatim extraction drops >95% in controlled Pythia runs).

6. SPECULATION (my inference — no source)

• (X) All LOC estimates in §1 and §3 are engineering guesses for this port.
• (X) No published self-play run exists at ≤1B total / ≤100M active. The smallest points found are 4B (R-Zero), 7B (SGS, CompassPlay), 1.5B (VH-GPO, 10-15 sweep), 30B (SPADE, Explorer-Zero). A byte-level, 57M-active, MoE+Engram model is outside the published evidence; every row is a transfer.
• (X) Whether HeirCommit’s fresh-probe confirmation resolves at 128 tasks. Our paired-eval resolution is estimated 0.002-0.005 BPB (AGENTS §3.1, unverified); the power of a 128-task pass-rate test against a round-to-round difference is computed nowhere I read. Measure it first — a confirmation gate that cannot resolve a difference always passes.
• (X) The JVP reward is affordable on the port, not on the Rust trainer. One forward-mode JVP per program per round on a 9.2M model is cheap in Python; the Rust trainer is launch-bound and would pay per-launch overhead for a per-program scalar. I measured neither.
• (X) A mutation-only proposer may be enough. All 14 rows use a learned proposer; none tests “mutate the existing 3 templates” as a baseline. It is the cheapest arm and the one that could make rows 2 and 7-10 unnecessary at our scale.
• (X) The band and the anchor are the same thing (difficulty regulation) at different granularities — the band on task difficulty, the anchor on model identity. No paper I found says so.

7. Open questions

1. Nothing published at our scale (§6) — every row is a transfer.
2. 2609.30063’s model sizes and per-scale compute are not in the sections I read (§3-§4.1): I can cite its scaling law and token budget, not a parameter count. I did not fetch its appendix.
3. Whether a byte-level proposer can write a runnable Python function inside a byte budget at 57M active. Every proposer paper is a token-level LLM writing fluent code; we spend 3-4× more positions per character.
4. docs-site/tools/manifest.mjs has not been updated for this document (this task was restricted to one file); python3 tools/check_doc_refs.py will flag it until that line lands.

---

Sources (arXiv IDs; how each was verified)

Full text (F) — download + read_paper_section (HTML endpoint): 2609.30063 · 2608.19197 · 2605.22217 · 2610.22029.

Abstract read (A) — get_abstract, full abstract: 2607.22529 · 2604.20209 · 2609.32228 · 2610.09856 · 2609.36750 · 2607.05904 · 2602.13103 · 2601.18778 · 2608.21871 · 2606.22688 · 2605.31126 · 2505.03335 · 2508.05004 · 2401.01335 · 2401.10020.

Snippet only (S) — title + ~280-char abstract: 2610.19868 · 2610.13995 · 2609.34205 · 2609.32870 · 2605.16727 · 2605.09959 · 2608.26582 · 2603.09206 · 2602.21320 · 2604.20051 · 2603.22352 · 2608.01559 · 2605.16315 · 2607.07436 · 2605.19576 · 2607.12790 · 2610.12789 · 2609.38661 · 2610.14515 · 2606.04516 · 2601.05870 · 2608.17253 · 2601.13566 · 2606.30571 · 2609.37447 · 2610.20866 · 2609.21617 · 2610.14883 · 2609.36224 · 2610.15449 · 2606.09701 · 2610.05346 · 2610.21156 · 2610.00903 · 2607.19354 · 2601.08198 · 2512.07175 · 2610.05978 · 2603.03583 · 2610.05383 · 2605.23019.