carryover-lab/change-bench

Change Bench

An open scorecard for one question: when a learned robot controller's body changes, what handles the change best, at what cost, and what does it forget?

Entries registered under the protocol face the same four rivals (see PROTOCOL.md). One of them is deliberately cheap: just tell the planner what changed. If a told number does as well as learning from experience, the entry has to say so. A claim that a method improves on how a controller handles a change holds only if the method beats the strongest cheap rivals at the same budget while keeping what it knew; a method that only beats weak baselines is not shown to be useful. Negative and null results belong in the bench as entries in their own right.

Author: Mimarin O. Status: v0.1, a local release package (v0 plus entry two). Not yet published anywhere.

Entry one: card 03, a told planner against practice on a known knee change

Entry one is a historical development illustration. It was run before the full prospective protocol in PROTOCOL.md was written, and the protocol was written after this screen, not registered for it. Its own rule, thresholds and checks were fixed before its data (see below), but it departs from the protocol in these ways:

• two of the four rivals were not run (fresh machine, pooled learner), and no reason for leaving them out was recorded before the data;
• retention was not measured for the told arm;
• the learned arm's retention and cost come from earlier records of the working programme, partly released here and partly context only (see RESULTS.md).

Setting (simulation only): the DeepMind Control Suite walker, run by the released TD-MPC2 MT30 48M multitask model with its weights frozen. The change: the right knee's actuator gear is halved (50 to 25), so the knee delivers half the torque for the same command. The skill scored is running (walker-run), which no arm practised after the change.

Three arms, all scored on the same ten evaluation episodes (bank seeds 1000 to 1009):

Arm	What it does	walker-run mean
Stored old solution (N)	the released model, unchanged, on the changed body	334.2
Learned dynamics (Df)	walking practice on the changed body; only the latent dynamics model is updated (mean of three training seeds)	547.7
Told planner (K-plan2)	no training; the planner is told the knee now delivers half the torque and plans within that limit	563.0

The told planner met the matching rule written before the data (mean at least Df minus T, where T = 36.75 is the noise threshold fixed in advance): 563.0 against 547.7. Paired episode by episode against each Df seed's saved results the mean differences are +45.9 (seed 2), -0.6 (seed 3) and +0.5 (seed 4). The identity check passed exactly: the same code with the told factor set to one reproduced the stored old solution's ten saved episodes with a largest difference of 0.0. Every pre-written implementation check passed (torque equivalence, no clipped command, knee inside its told range, every model boundary converted).

What this means: for this known, one-number change, telling the planner the change reached the level that practice reached, with no training at all. The first honest result on this bench went to telling, not learning.

The earlier INVALID run, and why

The first attempt (results/entry-01/invalid-first-run/) is published and does not count. That runner re-implemented the planner's search loop so it could apply the told range at every clamp site. Its identity arm (told factor one) had to reproduce the ten saved episodes within 0.001; it reproduced nine exactly and missed episode 8 by -29.5. The rule written before the run makes that INVALID, so its told-arm number is quarantined: never read as a result, never compared or pooled with the valid run.

A diagnostic (results/entry-01/diagnostic/) ran three variants of the identity path. The released planner with only the knee hook and a trace wrapper (P1) reproduced all ten episodes. Adding the re-implemented planning function (P2, and P3 with further wrappers) reproduced the same -29.5 miss on episode 8, with the first difference at decision 4250: a largest action difference of about 2e-6 that then compounded over the episode. The diagnostic labels this a replica-associated mismatch and states that the label locates the problem; it does not prove a cause. The valid rerun therefore does not re-implement the planner at all: it leaves the upstream planning code unmodified and changes only the units at the model boundary. Its identity arm reproduced exactly.

Disclosure: the invalid run's told-arm number already existed in a file when the rerun was built. The classification rule and thresholds did not change between the two runs, but the rerun was not blind to that file.

Entry two: a screen of the challenge, a walker rebuilt without feet

Entry two stopped at its screen: no judged stage 1 comparison ran. Entry 02 is a separately specified stage 0 engineering screen; its own rule was fixed before execution. The four-rival adaptation comparison was planned for later stages and did not run. Its planned rivals were a fresh machine and stored solutions in stage 1, a calibration rival and a pooled learner in a later full experiment. Its stage 0 first asks whether the body change is a consequential challenge for the unadapted model; it can only reject the setup or pass it on, and it selects no winner.

Setting (simulation only): receiver R is the DeepMind Control Suite walker with both feet and both ankle motors removed, thighs shorter, shanks longer and the torso heavier, driven by the released TD-MPC2 MT30 48M model through a declared mapping into the walker's observation and action slots. The metric is upright distance: the torso's forward displacement summed over an episode's decision boundaries while it is upright.

The registered rule (fixed in code before any episode) calls the change consequential only if the unadapted model on R (Z) reaches at most half the upright distance of the released policy on the healthy walker (H) and the paired bootstrap interval of mean(H - Z) lies above zero. Over ten paired episodes, Z recorded 46.00 m against H's 34.51 m; the interval of mean(H - Z) is -20.32 to -1.23 m. Both conditions fail: NOT CONSEQUENTIAL. Every check passed (identity and transport reproduced exactly with action hashes, the healthy positive check, every counter check; a trained fallback reference walked R, 42.12 m, where a simple gait screen did not). Cost: 7.376 GPU hours charged across both attempts.

What this means: in this registered simulation screen, the chosen receiver did not meet the predeclared consequence criterion, so it does not advance to the adaptation comparison. This is a boundary result for this setup, not evidence that any method learned transfer. Details, limits and cost: RESULTS.md, "Entry 02 in detail".

The earlier INCOMPLETE attempt, and the disclosure

The first attempt (results/entry-02/incomplete-first-attempt/) is published and does not count. Its GPU fallback could not restore its best snapshot (the snapshot kept only part of the model state), so its counter checks never reached the record and the registered rule classed it INCOMPLETE: an execution failure, not a scientific null. The repair (full, strict snapshots; checks written as they are made; full tracebacks) was witnessed on CPU and rehearsed on the GPU before one repaired attempt ran; the rule, thresholds, receiver, seeds and banks did not change, and the admission budget was raised from 7 to 12 GPU hours before that attempt. Disclosure: the first attempt's outcome fields were seen while its failure was being located, before the repaired run, so the repaired attempt is not an unseen independent replication.

What is shown, and what is not

Shown:

• In one simulated body, for one known change described by one number, a planner told that number matched the learned dynamics update on the withheld running skill, under a rule fixed before the data.
• The comparison is honest about its controls: the identity check reproduces the saved baseline exactly, and the invalid first attempt is published with its cause as far as it was located.
• Entry two: for one rebuilt simulated walker, ten paired episodes and one metric, the unadapted pretrained model was not hurt enough by the change to make it a consequential challenge under a rule fixed before the data, with every check passed; the INCOMPLETE first attempt and its repair are published.

Not shown:

• This is a development screen on ten examined episodes of one simulated change. The evaluation bank had been used before, there is one told run, and the rule is a development heuristic, not a calibrated statistical test.
• It does not show that experience has no value. The change here was known exactly and fits in one number. The case where the change must first be found from data is untested with a told planner: an earlier screen (idea 01) estimated the knee gain from walking data (a factor of about 2.0) but applied it with a blind wrapper that doubled commands after planning, and reached only partial recovery (376.9), so it does not settle that case either. Changes that one number cannot describe (several joints, drift, unknown faults) are untested.
• The told planner keeps the healthy body's value function and policy prior; it is not an oracle controller or a ceiling for calibration.
• Retention was not measured for the told arm (running only; its weights are never changed). The learned arm's two-task retention comes from the earlier Gate A reading (released in results/entry-01/inputs/); its running-backwards and cross-body figures come from a later working-record reading that is not released and are context only (see RESULTS.md). None of them comes from this entry's runs.
• Two of the four rivals in PROTOCOL.md (fresh machine, pooled learner) were not run for entry one.
• Entry two is not an arm comparison: no judged stage 1 comparison ran, and it shows nothing about which way of handling a change is best. Its reading holds for its metric, task, mapped interface, reset conditions and ten paired episodes. Upright distance is accumulated displacement while upright, not proof of safe or reliable walking. The unadapted model's higher number on R may reflect the body's geometry and the metric; the screen does not isolate why. It does not show that all body changes are easy, that the model understands its body, that history compounds, that any adaptation method wins, or that the programme's aim is refuted. Its repaired attempt ran after the first attempt's outcome fields had been seen.
• Nothing physical: no real robot was involved.
• The check "executed command is twice the model-space command" is derived from the logged executed commands, not an independent measurement.

Reproduce

What is in this package: the runner scripts (scripts/), their offline tests, the comparator inputs the runner reads (results/entry-01/inputs/), and the result records of the valid run and the invalid run with summaries of the diagnostic (results/entry-01/; the diagnostic's per-decision traces and replay files are not included). For entry two: its stage-0 runner, wrapper and tests (scripts/entry2_*, crossbody_logic.py), and the repaired attempt's records with every evaluation block, the bound identity record, the INCOMPLETE first attempt and the repair evidence (results/entry-02/). See results/entry-01/ENTRY.md and results/entry-02/ENTRY.md for every file and its hash, and MANIFEST.sha256 for the sha256 of every file in the package.

1. Offline logic tests (Python 3 and NumPy only, no GPU, no simulator):

   cd scripts
   python3 -m unittest test_told2_logic test_told_logic test_calib_logic test_told_check2_boundary test_recompute_entry01 \
     test_entry2_stage0_logic test_entry2_stage0_run test_entry2_receiver test_recompute_entry02
   bash test_entry2_stage0_v2.sh
   

   Expected: 218 tests, OK, 1 skipped; then "10 passed, 0 failed". The skipped test (in test_calib_logic.py, kept byte-identical to the run's copy) looks for the Gate A reading at its working-record path; test_recompute_entry01.py runs the same check on the released copy.

2. Offline recomputation of the results table (Python 3 and NumPy only), from the package root:

   python3 scripts/recompute_entry01.py
   

   It reads only released files (the Gate A reading, the seed 2, 3 and 4 Df records, both arms and told2.json), recomputes N 334.1976, Df_bar 547.7121, the told mean 562.9894, the paired differences +45.9015 / -0.5978 / +0.5283, T 36.7536 and the threshold Df_bar - T = 510.9585, the identity check, the registered outcome and the learned arm's cost, and ends with "AGREES with told2.json on every recomputed value" (exit 0) or lists every disagreement (exit 1).

   And for entry two:

   python3 scripts/recompute_entry02.py
   

   It reads only released files (results/entry-02/: the eleven evaluation blocks, the bound identity record, the gait screen, the fallback's check log, the ledger and the job log lines, both attempts' records), rebuilds the decision record from the evaluation blocks, applies the registered rule (the run's own decide()) and a second implementation written from the design text, and prints mean H 34.507331 m, mean Z 46.001543 m, the interval -20.323184 to -1.230142 m, the walkability bar 8.626833 m, the CPU reference 1.373488 m, the fallback 42.121987 m (step 30,000), T 148.463005, NOT CONSEQUENTIAL, the first attempt's class INCOMPLETE and the cost (7.375629 GPU hours charged). It ends with "AGREES with stage0.json on every recomputed value" (exit 0) or lists every disagreement (exit 1). The slot-map, non-mutation and receiver-XML checks need the simulator and are taken as recorded.

3. Check the files: shasum -a 256 -c MANIFEST.sha256 from the package root.

4. Full GPU rerun of entry one (entry two supports offline result recomputation; a turnkey end-to-end rerun is not supplied). You need:

   • TD-MPC2 at commit e9f59321933cbc8e11a002b842adc7d4ffae8ff1 (https://github.com/nicklashansen/tdmpc2); the runner refuses a tdmpc2.py whose md5 is not a50fb6c850b49c60d698e50c244f3bf7.
   • The released MT30 48M checkpoint mt30-48M.pt (md5 d44e05ecce371b1fb7965d54bd23b3a1, sha256 bacb9ae1891a9b03dc3942a287080beb573220ea9d0263c5efd7a94a5c2ec419).
   • MuJoCo 3.1.2 and upstream's Python dependencies; a GPU (the recorded run used one AMD GPU with a ROCm build of PyTorch 2.7.1).
   • The comparator inputs, which are in this package under results/entry-01/inputs/.

   Lay out a working directory of your own (<ROOT> below) exactly like this:

   <ROOT>/src/tdmpc2-e9f59321933cbc8e11a002b842adc7d4ffae8ff1/tdmpc2/   upstream checkout, plus every scripts/*.py
   <ROOT>/ckpt/mt30-48M.pt                                             the released checkpoint
   <ROOT>/calib-inputs/gate_a_reading_2026-10-11.json                  from results/entry-01/inputs/calib-inputs/
   <ROOT>/calib-inputs/seed2-Df-bridge_adapt.json                      from results/entry-01/inputs/calib-inputs/
   <ROOT>/told-inputs/seed2-Df-bridge_adapt.json                       from results/entry-01/inputs/told-inputs/
   <ROOT>/told-inputs/seed3-Df-bridge_adapt.json                       from results/entry-01/inputs/told-inputs/
   <ROOT>/told-inputs/seed4-Df-bridge_adapt.json                       from results/entry-01/inputs/told-inputs/
   

   For example, from the package root:

   mkdir -p <ROOT>/calib-inputs <ROOT>/told-inputs
   cp results/entry-01/inputs/calib-inputs/*.json <ROOT>/calib-inputs/
   cp results/entry-01/inputs/told-inputs/*.json <ROOT>/told-inputs/
   cp scripts/*.py <ROOT>/src/tdmpc2-e9f59321933cbc8e11a002b842adc7d4ffae8ff1/tdmpc2/
   

   (calib-inputs/seed2-Df-bridge_adapt.json and told-inputs/seed2-Df-bridge_adapt.json are the same file; the runner reads the first as the saved A block and the second as the seed 2 Df record.) Then run:

   export CHANGE_BENCH_ROOT=<ROOT>
   export BRIDGE_PY=<PATH_TO_YOUR_PYTHON>
   export BENCH_PROGRESS_FILE=<A_FILE_FOR_PROGRESS_LINES>
   bash scripts/told_check2.sh
   

   Everything in angle brackets is a placeholder. The runner refuses to overwrite any existing output. The Df records are released with one path prefix redacted, so a rerun records the released files' sha256 values, not the original ones in told2.json; ENTRY.md maps each released hash to its original. The runner does not check those hashes; it checks the values it reads (N, each seed's Df mean, the evaluation seed and the changed joint).

Notes on the released scripts:

• told_check2.py, told2_logic.py, told_logic.py and calib_logic.py are byte-identical to the files that produced the valid run; their sha256 values match the runner_sha256 block in told2.json.
• calib_check.py, told_check.py and bridge_adapt3.py differ from the run's files only in the name of the progress environment variable (now BENCH_PROGRESS_FILE). told_check2.sh has its private default paths replaced by placeholders. Details in RELEASE-CHECKLIST.md.
• Comments in the code cite files of the private working record (paths under review/, ideas/, results/); those files are not part of this package. Names such as Astra, Cursor, Fable and Opus in comments refer to the AI model families that audited the code.
• Path fields inside the result records and the comparator inputs were replaced with <REPRO_ROOT> and <VENV>; nothing else in them changed.
• recompute_entry01.py and test_recompute_entry01.py were written for this release; they were not part of the run.
• Entry two: entry2_stage0_logic.py, entry2_receiver.py and crossbody_logic.py are byte-identical to the files of the repaired attempt (their sha256 match runner_sha256 in results/entry-02/stage0.json), as are test_entry2_stage0_logic.py, test_entry2_stage0_run.py, test_entry2_receiver.py and test_entry2_stage0_v2.sh. entry2_stage0_run.py and entry2_gait_search.py differ only in the progress variable's name (BENCH_PROGRESS_FILE). entry2_stage0_v2.sh has its private default paths replaced by placeholders (CHANGE_BENCH_ROOT, BRIDGE_PY), the progress variable renamed, the pinned sha256 of bridge_adapt3.py updated to the released file (original kept in a comment), and its launch mode, which used a private GPU launcher, now refuses; bash -n passes. The run also used bridge_adapt3.py and bridge_logic.py, released with entry one. Three scripts keep home-relative paths that name no user or machine: ~/repro/... in the identity binding of entry2_stage0_logic.py, and ~/.venvs/tdmpc2/... in a comment of entry2_receiver.py and a usage line of entry2_gait_search.py.
• A full GPU rerun of entry two needs the same upstream commit, checkpoint, MuJoCo 3.1.2 and dm_control 1.0.16, and a step-0a identity record. The runner refuses an identity record whose sha256 is not the bound original (981bdc02...); the released copy has one path prefix redacted, so a rerun needs either that original or a new step-0a record with the binding in entry2_stage0_logic.py changed and stated. The step-0a producer script is not in this package. recompute_entry02.py and test_recompute_entry02.py were written for this release; they were not part of the run. The released wrapper entry2_stage0_v2.sh comes from the working copy (72e99cdd...); it was not itself hash-bound in the run's manifest, so not every executed dependency is cryptographically bound. Offline recomputation is unaffected.

Submit an entry

Version 0 of the bench is public at https://huggingface.co/datasets/carryover-lab/change-bench; this version (v0.1, adding entry two) is the pending update. An entry is submitted as a public contribution to the bench's page with:

1. A registration written and timestamped before any result is seen: the change, the skill scored, the evaluation bank, the rule that classifies the outcome, the thresholds and the budget.
2. All four rivals of PROTOCOL.md at matched resources, or a written reason for each rival left out (shown in the results table, never hidden).
3. Code that runs, per-episode raw results, an identity or null check that reproduces a saved baseline, the full cost accounting and the retention measurements.
4. Every run, including invalid and negative ones, with its cause where known.

An entry is listed in RESULTS.md with its outcome read by its own registered rule, whichever rival wins.

How this was made

The code, runs and write-up were produced with AI coding assistants working under the author's direction. Claims were reviewed separately by AI models of other families, and selected numbers were recomputed independently from the saved records. Errors were found and corrected along the way, some after a claim had been recorded; the invalid first run of entry one is one example. No external human lab has validated this work.

Licence

• Code (everything under scripts/): Apache License 2.0 (full text in licenses/Apache-2.0.txt).
• Text and results (this README, PROTOCOL.md, RESULTS.md, RELEASE-CHECKLIST.md and everything under results/): Creative Commons Attribution 4.0 International (CC BY 4.0; full text in licenses/CC-BY-4.0.txt).

See LICENSE. Attribution: Mimarin O., Change Bench, 2026. The scripts run inside, and told_check.py contains an adapted copy of the planning routine of, the upstream TD-MPC2 code, which keeps its own licence.