How SPADE turns self-generated worlds into a bounded training loop

The starting boundary

A pretrained policy writes a small executable world, enters it, attempts the task, and updates its own weights from the outcome. On the next round, it can write another world shaped by what it can now solve. This loop can improve the policy without human-written question-answer training pairs or demonstrations from a stronger teacher. The demonstrated result is online post-training: a pretrained model updates inside environments that can reject malformed tasks and check outcomes. Training begins from pretrained weights, with the model's prior knowledge still in the loop.

SPADE v1 was submitted on 19 August.[1] SPADE trained Qwen3-4B-Instruct-2507, Qwen3-8B, and Qwen3-30B-A3B-Instruct-2507.[1] SearchMaster v1 was submitted on 3 August.[2] SearchMaster trained Qwen3.5-9B.[2] Through 23 August 2026, SPADE and SearchMaster were the latest primary systems in the cited literature to update pretrained LLM agents online on self-generated tasks without human-written QA pairs or stronger-teacher demonstrations. Absolute Zero is an earlier result on Qwen2.5 and Llama-3.1 backbones.[3]

Removing QA pairs leaves much of the laboratory intact. The runs start from pretrained weights and use human-designed role prompts, task forms, filters, optimizers, reward settings, and rollout budgets. SPADE retains sampled corpora, runtime validation, environment memory, and repeated rollouts.[1] SearchMaster retains a local corpus, task filters, a frozen verifier, and proposer and solver rollouts.[2] Absolute Zero retains Python execution and self-generated program buffers.[3] A qualified yes therefore describes a parameter-updating agent inside an engineered world whose information and checks still come from outside the updating loop.

SPADE makes the remaining machinery visible in one object. Its games run begins when the policy writes the world that will later become its training data.

The executable environment

SPADE gives one shared policy two roles.[1] As Environment Designer, it emits a Python environment with reset() and step(), hidden state, permitted actions, transitions, reward logic, verification code, and a privileged hint. As Reasoning Agent, the same policy enters that environment and plays it both with and without the hint. The agent return trains the solving role, while the return gap between the hinted and unhinted plays helps train the designing role; both updates change the same weights.[1]

Before any optimization, this generated program defines the environment contract: what state exists, which actions are allowed, how an episode resets, which outcome counts, and what resource boundary the run will enforce. SPADE parses and runs candidate code before admitting it.[1] That execution can show that the program has a determinate result. It cannot, by itself, show that the task contains useful new material or that its reward encodes the capability the experiment intends to train.

The sampled corpus and the executor do different work. A corpus can give the designer subject matter beyond the patterns it would otherwise repeat. Execution supplies consequences and a validity check. Absolute Zero shows why those jobs should remain separate: its shared proposer-solver policy reported bounded code and mathematics gains without an external task corpus, but it still began from pretrained program priors, retained self-generated program buffers, and used Python to validate tasks and answers.[3]

For an implementation, that distinction yields two explicit choices. Define the environment contract before training, including task syntax, state transitions, reset behavior, outcome invariants, and limits. Then give proposal a legitimate source of task material: an executor or simulator may be enough for bounded program transformations, while a corpus or changing environment state is needed when the desired frontier requires semantic breadth beyond the model's preferred patterns. Once SPADE has written such a candidate world, admission must decide whether it is fit to become training data.

Task admission

A Python environment can execute twice and still be a bad task. Its output may be ambiguous, its test may accept a shortcut, or its reward may check a property different from the intended invariant. SPADE parses generated code and applies structural and runtime validation before pool admission.[1] That screening keeps a concrete program's defects from feeding directly into the next generation round.

A controlled comparison shows what this boundary can and cannot establish. In Survive or Collapse, every gate-off configuration on Qwen3-4B Python output prediction drove validation accuracy near zero, across the tested proposer and solver rewards. The companion task used a deterministic 15-operator language; there, a grounded solver could remain near baseline without a separate filter because the interpreter already guaranteed one unambiguous integer output. The required function was deterministic validity, whether supplied by an explicit gate or by the environment itself.[4]

That result supports gating candidate tasks before optimization for executability, determinism, unambiguous outcomes, and the intended checked property. For these narrow tasks, the gate establishes deterministic validity; novelty, learnability, relevance, and safe execution require separate tests. A wrong specification can still reward the wrong behavior. In an adjacent RLVR experiment, a checker that matched only the listed examples—an extensional checker—rewarded the model for enumerating instance labels. When researchers renamed objects while preserving the same relational structure—an isomorphic perturbation—the learned output no longer preserved the intended rule.[6]

Admission monitoring should stay equally narrow. Before training, predeclare how often the audit runs, which independently checked sample it uses, how long a deterioration must persist, and which clean checkpoint receives a rollback. At each audit, record proxy reward against grounded accuracy, false-positive admissions, verifier disagreement, and shortcut incidence. SearchMaster measures the minimum depth of a successful search and repeated document opening.[2] Survive or Collapse tracks the gap between proxy reward and grounded accuracy alongside narrow validation probes.[4] Persistent proxy improvement alongside falling grounded accuracy or executability is a failed audit: pause updates and return to the last checkpoint that passed. A noisy or contradictory sample is inconclusive, so updates stay paused for review. Each experiment must calibrate its sample, cadence, and thresholds locally because the sources supply directional diagnostics rather than portable numerical values. The direct gate result covers narrow Python and deterministic-language tasks, while the verifier-gaming result shows that even deterministic checks can encode the wrong invariant.[4, 6]

Passing admission therefore says that SPADE has a well-defined candidate environment with a checked outcome. The next question is whether this checkpoint can learn something useful from it now.

The adaptive curriculum

SPADE answers that question by playing each admitted environment several times. Some plays reveal the privileged hint and some do not. A large return gap identifies a world that the current policy can solve with help but not yet reliably solve alone. This hint-based regret makes difficulty relative to the learner rather than a permanent property of the task.[1]

The designer then keeps the curriculum moving. It receives current-policy results, draws on a memory of earlier environments, and produces a new set after a fixed training window. Its own update waits until that window ends, so some plays were generated by slightly older weights. SPADE reweights those plays toward the current designer and caps extreme corrections so a few badly mismatched samples cannot dominate—truncated importance sampling. The loop is therefore partly off-policy: it mixes fresh experience with delayed, reweighted updates. This supports refreshing proposer and solver experience as the learner changes while preserving delayed updates and replay as live design choices.[1]

The corpus keeps a different part of that moving distribution alive. In the no-corpus SPADE run, 41 accepted environments during steps 290–312 stayed within the same rotating-maze family despite changes to maze layouts and minor rule text; the compared corpus-grounded and no-corpus runs had different acceptance rates over that window.[1] That observation motivates measuring task-family concentration alongside difficulty. It does not turn a corpus into a universal requirement, as the executor-bounded Absolute Zero result already shows.[3]

Retained environments create another measurement problem. Log task age, how far the current policy has moved from the policy that generated each sample—policy mismatch—replay share, and family concentration. Those measurements let the experiment choose its own buffer size, age limit, and refresh interval.

Even a fresh, valid, learner-relative task can train the wrong skill. GASP selected 146 human-authored LiveCodeBench problems as goalposts and used them to steer generated stepping stones; its comparison with unguided self-play shows why difficulty and relevance are separate tests.[5] Because those goalposts are human questions, this is a diagnostic comparison rather than evidence for the strict zero-QA recipe. For SPADE, relevance must therefore be tested against a separately chosen target distribution rather than inferred from hint-based regret.

The run now has a precise mechanism to test: admitted executable environments, grounded outcomes, learner-relative selection, refreshed experience, memory, and corpus breadth. Only counterfactual controls can show which part of the observed checkpoint gain came from that moving loop.

Causal acceptance

On Qwen3-30B-A3B-Instruct-2507 in the games setting, SPADE reports a best-checkpoint average of 58.3 across eight held-out benchmarks.[1] That is 5.3 points above its strongest fixed-environment baseline.[1] Each variant is represented by the checkpoint with its best suite average.[1] The fixed-environment comparisons match 400 training iterations, not total rollouts or FLOPs.[1]

Use the same SPADE games run as the judged artifact and change one factor in each comparison. Start with the unchanged base, using the same untouched target evaluation, to ask whether weight updates helped. Then run a no-update policy with the same tools, tasks, rollout budget, checkpoint-selection rule, and evaluation. A clear advantage over that arm rules out elicitation or extra practice as the whole explanation for the measured gain.

Static synthetic supply and fixed-task RLVR freeze different inputs. For static supply, have the same SPADE generator create a batch of environments before training, then stop adapting that supply; hold the base model, solver update, verifier, total generation and execution budget, checkpoint rule, and evaluation fixed. This tests whether task supply that responds to the current learner adds value over the same synthetic pipeline run in advance. For fixed-task RLVR, replace the self-generated environments with a separately specified task set that stays unchanged; hold the base model, solver optimizer, verifier, training budget, checkpoint rule, and evaluation fixed. This tests the generated-task pipeline against ordinary verified-reward training on a fixed task distribution.

Next freeze only the SPADE designer while holding its model identity, memory, solver updates, task budget, checkpoint rule, and evaluation constant. That arm asks whether learning in the proposer contributes beyond continued solver training. The published frozen-designer variants also remove memory or replace the designer with GPT-5.5, so they favor the adaptive package without isolating proposer learning.[1] A no-corpus arm keeps the executor and training procedure while removing the external source of task material; it tests whether the reported breadth depends on that source. A verifier swap keeps the training run fixed and scores it through a separately specified checker; it tests dependence on one reward rule. The guided goalpost condition belongs here only when the application allows human target questions; it tests relevance within that scope.

Finally, judge every arm with multiple seeds and a checkpoint rule declared before looking at results. A temporal holdout uses tasks that became available after the training-data cutoff, catching gains explainable by access to earlier content. A procedural holdout changes how tasks are made—for example, the generator, templates, or corpus path—catching gains that depend on the training task-production procedure. Item-level decontamination checks direct overlap, and at least one evaluation path uses a checker that did not provide the training reward. SPADE and SearchMaster report transfer to held-out or live-web endpoints, but neither target study combines that full set of protections.[1, 2]

Before training, predeclare the primary measurement, uncertainty rule, budget accounting, held-fixed variables, checkpoint selection, and pass, fail, or inconclusive interpretation for each arm. A clear result rules out only the alternative explanation that arm tests. A failed arm rejects that specific causal claim; an uncertain or contradictory result is inconclusive and keeps the claim withheld. No source validates one numerical decision threshold for every experiment. Choose SPADE as the research base only when the project can run the no-update, compute-matched static-supply, fixed-task RLVR, isolated frozen-designer, no-corpus, verifier-swap, multiple-seed, predeclared-selection, and untouched-evaluation comparisons. Otherwise, treat the author-reported gain as a hypothesis and stop before deployment.

The deployment boundary

Once SPADE's proposed run is tied to those acceptance arms, resource choice becomes a question of experimental fit rather than headline performance.

Implementation status as of 23 August 2026:

The table distinguishes runnable research stacks from a design reference. Repository availability establishes a research starting point. SPADE's runtime validation checks generated environments; security containment remains a separate job. Generated Python needs process isolation plus CPU, memory, time, filesystem, and network limits. Search verifiers need retained evidence and measured failure cases. Treat agreement among verifiers from the same model lineage—same-lineage agreement—as corroboration, and use a different model or procedure for the independent evaluation path. Operational monitoring should extend the admission panel with diversity, held-out performance by checkpoint, and verifier-swap failures.

The supported implementation is therefore a contained research experiment whose causal arms can actually be run. Deployment in self-judged writing, strategy, ethics, or scientific truth lies outside this evidence and requires its own independent evaluation and safety boundary.

What this run cannot settle

Containment and causal controls leave a narrower question: which conclusions remain unsupported even after both pass?

The cited evidence supports a short research experiment over executable worlds and fixed evaluations. The strongest positive results are mostly author-reported preprints, and the cited literature does not establish an independent reproduction. The remaining control gaps keep the causal estimate provisional, while the monitoring evidence supports an experiment-specific stopping plan rather than a portable unattended rollback policy.

The public artifacts also leave a few implementation boundaries. SPADE describes an LLM feasibility screen in its tool-use branch but does not identify the screening model.[1] Its paper and repository do not establish independent reproduction of the linked child artifacts or secure containment for generated code.[7] Absolute Zero's executor warning keeps it inside a contained research setting.[8] SearchMaster still lists its self-play code, local-search setup, generated data, and checkpoints as planned releases.[10] The cited literature through 23 August 2026 is finite, so the dated frontier does not establish exhaustive field-wide priority.

SearchMaster evaluates on live-web endpoints after training in a fixed local corpus.[2] GASP uses human-authored goalposts to steer target relevance.[5] Together, these results establish transfer to fixed endpoints and show that an external target can steer relevance. Sustained creation of reliable facts or principles beyond pretrained expressivity, available corpora, executable consequences, verifier assumptions, and human-chosen targets remains untested; a reachable task frontier may differ from the one a user values.

The open dependency is how the useful and truthful frontier could keep expanding after those information sources run out.

The information frontier

SPADE can choose which executable world to try next, yet its run still receives novelty and truth from pretrained program patterns, sampled documents, code semantics, human-written rules, and evaluations that the updating policy does not control. The policy can write the exam and take it; the laboratory must still decide whether the exam is valid, whether the result is real, and whether the improvement counts.

That is the bounded answer. Teacher-free self-play can remove human-written QA pairs and produce weight-update gains when adaptive task generation operates inside a world with external information, enforceable outcome checks, and an independent causal acceptance boundary. The external world and acceptance boundary remain part of the system.

The decisive open question is whether a pretrained agent can keep expanding a useful and truthful task frontier after exhausting its program patterns, corpora, and human-chosen target structure—without importing a stronger evaluator to select or judge the next frontier.