HarleyCooper/weight-space-breakout-iterative

Evidence index — 2026-11-03: Accepted repair from round 1 This repository retains its own historical protocol and results. Current evidence and status · Per-seed dataset.

Iterative Weight Space Breakout

Current weights: Accepted repair from round 1. This is a 17,253-parameter game controller, not a language model.

Live simulation · Pipeline source · Prime environment

The editor and all experiment game evaluations run on Prime. The simulation runs on Hugging Face CPU. A lightweight controller serializes and publishes verified weights. This iterative feedback protocol is separate from the earlier one-shot experiment.

Round	Incumbent	Candidate	Mean gain	Decision
1	1.4512	2.7773	+1.3262	Accepted
2	2.8535	2.4395	-0.4141	Rejected
3	2.8535	2.3789	-0.4746	Rejected

Each row uses 512 fresh matched seeds, so means in different rows are not directly comparable. Rejected candidates remain in the audit; the root checkpoint always contains the incumbent. The first run is capped at three editor responses.

Final audit

On 1024 separate seeds, initial faulty return 1.3018 and final selected return 2.9180; paired gain +1.6162, paired standard error 0.1108. This final audit was not fed to the editor or used to select a policy.

The accepted two-weight repair exactly restored the intact handwritten reference controller. The later attempts did not improve it. This demonstrates a working repair-and-deployment loop, not sustained recursive improvement or a new learned skill. The final selected policy cleared no boards in this audit.

Files

model.safetensors, policy.npz, and policy.json contain the selected policy. initial_baseline.safetensors preserves the known-bad start. manifest.json links its fingerprint, file checksum, plan, and round decisions. experiment/ preserves candidates and verifier reports. Every Hub commit is an immutable version; the demo resolves a revision before downloading and checks both hashes.

Hosted iterative weight repair

This extends the original one-shot experiment into a bounded feedback loop. It starts from the deliberately bad reversed-controls teaching policy, not a language model. The completed demonstration used environment 0.2.1. The subsequent 0.2.2 release adds complete source/setup documentation and corrects the prompt's claim about tool availability; it does not change the recorded run or its checkpoints.

1. Freeze a run plan (three rounds by default, one Qwen response per round).
2. Send the current policy snapshot and its hash to harleycooper/weight-space-breakout@0.2.1.
3. Prime's hosted environment runs 32 practice games and provides short trajectories.
4. Prime-hosted qwen/qwen3.6-35b-a3b proposes up to 64 scalar assignments, with no tool use.
5. The hosted verifier validates the edits and compares the candidate and incumbent on 512 matched, fresh evaluation seeds. It accepts only a real change with mean gain greater than 0.10 and gain - 2 * paired_standard_error > 0.
6. The controller checks the verifier's hashes, publishes the accepted policy to a versioned Hugging Face repository, and requests a fresh hosted simulation using exactly that published revision. A rejected candidate is recorded, not promoted.
7. The next round starts from the accepted weights and receives a summary of the previous attempt. After the final round, the verifier reports a separate 1,024-game audit against the original faulty policy. That audit is not used for promotion.

Fixed boundaries

Practice seeds are 40000 + 32*round through 40031 + 32*round. Promotion seeds are 60000 + 512*round through 60511 + 512*round. Final audit seeds are 90000..91023. Rounds are zero-based and limited to 20 in the environment. The first published run is limited to three rounds and 4,096 output tokens per call. No GPU is needed for the game. LLM inference and hosted evaluation can incur Prime charges.

Harness disclosure: Prime's default harness advertised bash and edit tools. The task prompt prohibited their use (and inaccurately said they were unavailable). The controller requires exactly one completed model call and zero actual tool calls before accepting a trace. The audit preserves the advertised tool names and usage. Thus this run demonstrates edits made without tool use, not a technically tool-free harness.

The promotion rule is an engineering screen, not proof of general statistical significance. Adaptive search still needs independent replication. An unaccepted edit does not change the live policy. Results may plateau or all candidates may fail.

What runs where

• Prime: editor inference, practice games, verifier comparisons, final audit.
• Controller: lightweight orchestration, JSON validation, weight serialization, publication, and deployment checks. It runs no large model or evaluation games.
• Hugging Face: versioned policy weights and CPU inference/simulation.

The earlier one-shot model and its demo remain available as a separate experiment. Each round records its starting checkpoint, exact response, candidate hash, verifier report, accept/reject decision, published revision, and deployed episode result.

Future experiments: tools allowed

This first run establishes the complete handoff and uses one response per round. Future experiments will explicitly allow tools and multiple turns: inspecting tensors, running permitted practice games, testing candidate edits, and revising them before submission. That requires a new task/harness configuration and a declared interaction and compute budget; it is not enabled by clicking Play in the demonstration. The current controller intentionally enforces this first run's single-response protocol.

Keep the final evaluation and promotion logic outside the editor's writable runtime. Tool-assisted editors should receive practice feedback while the trusted verifier loads the submitted data-only patch in a separate process. Compare tool-assisted and single-response runs using separate result records rather than pooling their scores.

Relationship to Cree and Dakota

The same orchestration can be adapted, but the game verifier cannot measure language quality. See LANGUAGE_EXTENSION.md for the inspected repositories, existing scoring code, and the work needed before a language-model editing experiment.

Original-work credit

Independent conceptual replication attempt and teaching adaptation of Sparks of Weight-Space Programming by Rikiya Takehi, Jayden Teoh, Alex Zhang, and Omar Khattab (MIT CSAIL, November 2, 2026). Original X post · Experiment 1 logs. Experiment 1 identifies a game from weights. This project instead tests editing in an independently reconstructed game with handwritten faults. These are our results, not a reproduction of the original PPO training, simulator, or reported scores.