What a large-scale run would look like
A gated proposal for search-guided self-play with every-sibling labels, including what failed locally and what must pass before any cluster run.
This is a proposal, and its original compact-leaf route is currently blocked. Small-scale work built successor-closed corpora and trained students, but the exact-D4-label student ranked worse than exact D1, and a leaf-affordable NNUE student did worse again. The design below therefore describes the loop's intended architecture, not a run that is ready to scale. A redesigned student must first pass the offline sibling-ranking gate on one workstation. See is more computation the answer? §4.
The feedback loop and the machinery for running it beyond one machine do not exist. The direction is registered as a theory with stated falsification tests. It is written for readers who have followed the choice-and-chance, sibling trap, and more-compute pages.
The loop
Thousands of games run at once. At every position, instead of playing the move a policy likes, the system runs a fair search for every legal column under the same imagined futures and writes down all of the values. It then plays one of them (usually the best and sometimes a deliberate alternative), so the data covers moves a strong player would not make. A learner on the GPUs trains a public evaluator on that ever-growing, every-sibling dataset. When the learner produces a better evaluator, it is frozen and tested against fair D4 on fixed games. If it passes, it becomes the leaf of the search that generates the next round of data. Repeat until improvement stops.
The components
- Batched simulator. Thousands of boards in lockstep on the CPU (later, possibly, the GPU), proven move-for-move identical to the reference engine by the same differential gates the fast engine passed. The rules never change; only how many games run at once.
- Actors. Processes that run the search at each visited position, for each column, with shared chance scenarios across siblings, and emit one record per position: the board, the next disc, the rise clock, and the seven sibling values. The search is the existing fair expectimax with a pluggable leaf.
- Data shards. Append-only files partitioned strictly by seed role. Training seeds never touch evaluation seeds. Each shard has a manifest and content hashes, following the repository's seed-lease rules.
- Learner. A data-parallel trainer on however many GPUs are available, consuming shards and producing candidate evaluators. The original compact board evaluator failed its ranking gate, and a later leaf-sized NNUE failed too. A replacement might be a larger model used as a root prior or a cross-sibling set ranker. Any model placed at the leaves must be cheap enough to run millions of times per decision.
- Evaluator / gate. Every candidate is frozen and played through the public interface against fair D4 on a fixed paired cohort, with whole-game statistics. It is promoted to the search leaf only on a preregistered win. A candidate that reads anything a player could not see is disqualified.
- Orchestration. One configuration file describes actors, learner, evaluator, shard locations and budgets. A single workstation and a thousand nodes differ only in that file. The repository's agent skill for scale-out describes how that maps onto the common cluster shapes.
The order of work
The sequence matters more than the size:
| Stage | What | Where it runs | Gate to the next stage |
|---|---|---|---|
| 0 | Reconcile the original theory with the failed exact-label and leaf-capacity gates; choose a new student form without opening new seeds | this workstation | a preregistered redesign with a falsifiable offline ranking gate |
| 1 | Batched simulator with differential gates | this workstation | zero mismatches vs the reference over leased seeds |
| 2 | Actors + shards + learner, one iteration, tiny scale | this workstation, iGPU | evaluator trains; held-out sibling ranking measured on the locked panel |
| 3 | Three iterations at pilot scale | this workstation | ranking improves across iterations, or the theory is failing and says so |
| 4 | Compute-response test: double actor compute, hold everything else | this workstation, then a small cluster | paired 32-game SCREEN shows a gain beyond noise, or it does not |
| 5 | Scale-out | cluster | same gates, larger cohorts; whole-game bootstrap bounds on the paired difference vs fair D4 |
Stages 0–3 need no cluster. The current compact-leaf design stopped at its offline gate, before a feedback iteration. A successor must clear that local gate before any cluster run.
What would prove it wrong
The registered theory (TH-20260821-search-guided-self-play-at-scale-299ed02f,
on the theories page) commits to four failure conditions: held-out
sibling ranking that does not improve across iterations; no measurable gain
from doubling actor compute; a frozen student that does not beat fair D4's mean
on a fresh paired cohort with a positive lower bound; and any reading of hidden
information, which disqualifies a student regardless of score.
What is deliberately not promised
- A million-point mean. The theory claims that compute converts into strength through this loop; how far it goes is what the experiment measures.
- That the GPU will simulate games. Exact simulation stays on the CPU until a GPU version passes the same differential gates and beats the CPU end to end.
- That the architecture below has passed its gates. It has not; the compact leaf variants failed, and the redesign is still proposed.