Everything on this estate is self-attested until someone who is not me runs the tests. This page exists to make that as easy as possible: the runnable tests, what each decides, and a dated register of independent attempts that is honest at zero and updates as runs arrive.
One number here was retracted on 5 August 2026, by me and against my own case: 2.24, replaced by 0.49 with its interval. The corrections register is dated and public, checkable tonight on your phone.
The attempts register
This section renders from the replication-attempts register at every build. As of 2026-08-28: 0 independent attempts recorded. The register states its own rule: an independent run outranks the programme’s own in either direction, and a failed replication enters with the same prominence as a success.
No independent attempt has been recorded yet. That is the honest current state, dated above, and it updates the day an attempt with a checkable artefact arrives. The tests below say what each one decides, what a run can settle, and what its licence permits.
Choose the question before running a test
Start with the current claim status and its refuting observation. Use the versioned paper and the reproducibility record to identify what the available code can establish. Record the exact protocol and code versions before collecting new outcomes.
A demonstration on simulated or supplied data checks an implementation. A deciding study needs the appropriate frozen protocol, valid measurements and fresh observations. A code test passing does not establish an ARC proposition.
The tests
Sixteen runnable tests sit in the two repositories, and between them they name sixteen of the programme’s thirty papers. This section renders from the runnable-tests register, whose file identifiers were read from the repositories through the contents interface and whose folder dates were read through the commits interface, both on 9 September 2026. Nine of those sixteen papers link at least one of their own tests from their own page and seven do not, and the seven are Foundational, Paper I, Paper III, Paper V, Paper VIII, Recursive Dynamics and The ARC Theory.
Eight can be run today from their own instructions, three only in part and five not at all, and each of the eight that falls short says what is missing. None of the sixteen is a deciding study: eight are implementation checks and eight are pilot measurements.
What a run here can be is bounded by the repositories themselves. The validation repository’s own map of its experiments states that no tier in it means validated, replicated or independently confirmed, that nothing in it has been independently replicated, and that no result in it has been through peer review. The ARC Theory states that everything decisive is drafted and dated as a draft registration awaiting human filing, that nothing has been run and that no result is claimed.
Three of the sixteen sit under the MIT licence of the scaling challenge and may be re-used. The other thirteen sit in the validation repository, whose code licence reserves all rights: it permits reading the code, the data and the results to check the published results, it grants no other use, copying, modification or distribution without the prior express written consent of the author, and it gives an address for licensing enquiries.
No published register names a test. The kill conditions and the dated predictions are bound to papers, not to folders, so each card below shows the kill conditions that belong to the same paper and calls that adjacency, because that is what it is.
Does depth buy capability, and does alignment keep up?
Five tests bear on how a quantity rises as a system is given more depth. Two put questions to live models, one re-analyses what those runs wrote down, one regenerates the founding toolkit’s own figures, and one is a legacy kit for measuring the exponent in a system of your own.
T01 The foundational toolkit
Implementation check · runnable in part · reading to check, or re-use by written consent.
Decides. Whether the ARC scaling family fits across models. The folder’s instructions describe a toolkit that regenerates Paper I’s figures and its illustrative analyses; the repository’s experiments index describes the same code computing a per-model exponent, an R squared, an interpretation and a falsification verdict against the claim that the exponent exceeds one.
Run it in part. The instructions give python3 arc_principle_research_toolkit.py and the file sits in scripts/, so add that prefix. Needs Python 3 with matplotlib, numpy and scipy, and no key. Start at the paper-i-foundational folder.
What a run settles. A run that comes out as the instructions describe shows the toolkit reproduces the figures the paper prints. A run that does not shows the committed code and the published figures disagree, which is a finding about this folder and nothing wider. Neither outcome decides an ARC proposition: the repository grades this folder supporting, which it defines as a computational validation of a step rather than an empirical result. The library version pins are left for the author to fill, so a second machine may not reproduce the numbers exactly.
REPRODUCE.md 9ae3fd0 · folder last changed 5 July 2026 · Paper I, whose page links the experiments folder above this one and not this folder · same-paper kill conditions FALS-020, FALS-022 and FALS-023.
T02 The sequential and parallel exponents
Pilot measurement · runnable in part · reading to check, or re-use by written consent.
Decides. Whether depth compute scales capability with an exponent while sampling compute does not, measured as the average sequential exponent against the average parallel one across frontier models, with cross-model verification.
Run it in part. The instructions give python3 arc_paper_ii_validation_v2.py with its own flags, once per model, and the file sits in scripts/. A fresh collection needs Python 3 with numpy, scipy and a model client, and a key for each of the six providers, and the pins and the keys are both left for the author to fill. The per-model result files are committed and the repository states that no key is needed to re-run the analysis over them, so the arithmetic is checkable today. Start at the paper-ii-compute folder.
What a run settles. The instructions state the expected result: the average sequential exponent comes back positive, about 0.49 in aggregate, and materially above the average parallel one, which is about zero, reproduced within run variance across the six models and both problem-set sizes. A run that does not reproduce that separation is evidence against the sequential advantage as measured here. Neither outcome settles an ARC proposition, because the repository grades this folder a pilot, which it defines as real data with stated methodological limits. The repository records the early single-model estimate of about 2.24 as retracted and the robust cross-architecture estimate as about 0.49.
REPRODUCE.md 768ed99 · folder last changed 4 September 2026 · Paper II · same-paper kill conditions FALS-002, FALS-006, FALS-007 as retracted, FALS-022, FALS-031 and FALS-032.
T03 The alignment exponent against the capability exponent
Pilot measurement · not runnable for a fresh collection · reading to check, or re-use by written consent.
Decides. Whether alignment scales with reasoning depth and how that compares with capability, measured across eight models under a blinded scoring protocol with bootstrap confidence intervals. The attempts register puts the same question this way: whether a stated value survives deletion of its statement, or was resting on a document.
Not runnable as published. The committed results are the version-five alignment-scaling runner’s: the repository index records six subject-model finals under results/v5-final/ from that runner, and lists the version-six runner as not yet run. So the command that reproduces what is published is python3 scripts/arc_alignment_scaling_v5.py with a model flag, once for each of the six subject models the index names. That needs Python 3 with numpy, scipy, a hashing module and an HTTP client, and a key for each of those providers, and the exact library pins and the key setup are both left for the author to fill, so a fresh collection cannot be run from the instructions alone. The folder’s own instructions file names the version-six runner as canonical and calls the earlier versions superseded. Start at the alignment-scaling folder.
What a run settles. The instructions state what a faithful run brings back: the recorded exponents inside their bootstrap intervals, with the alignment exponent architecture dependent and distinct from the capability exponent. A run that lands outside those intervals is a finding against the recorded measurement. Neither outcome settles an ARC proposition, because the repository grades this folder a pilot, blind-scored at version five. The design is checkable as it stands, because the models, the four token budgets of the depth sweep and the output schema are all stated. The benchmark paper states that its reference implementation stands at v5.4.2; the folder’s instructions file names the version-six runner as canonical and calls the earlier versions superseded, and the repository index lists that version-six runner as not yet run.
REPRODUCE.md 7bf4587 with arc_alignment_scaling_v5.py 1b95c18 · folder last changed 4 September 2026 · Papers III, IV.a, IV.b, IV.c and IV.d, and Paper III does not link it · same-paper kill conditions FALS-003, FALS-009, FALS-013, FALS-014 and FALS-015.
T09 The cross-programme re-analysis tools
Implementation check · runnable today · reading to check, or re-use by written consent.
Decides. Nothing on its own. These are cross-programme utilities that aggregate and re-analyse the raw results the primary folders produced. The folder calls itself the checks the checkers layer and states that it generates no primary data.
Run it. The instructions give python3 analyze_alpha_align_v5.py with a path to a results directory, and python3 per_scorer_check.py. Needs Python 3 with numpy and scipy, no key, and the primary results, which are committed; the version pins are left for the author to fill. Start at the analysis-tools folder.
What a run settles. A run tells a reader whether the published analysis follows from the results the primary folders wrote down. It cannot tell them whether those results are right, because this code never touches a model. The repository grades this folder tooling, which it defines as code used by other experiments and producing no result of its own.
REPRODUCE.md 024708a · folder last changed 5 July 2026 · Papers II, IV.a, IV.b, IV.c, IV.d and V, and none of the six links this test · no same-paper kill condition is recorded against this folder.
T15 The ARC scaling challenge, legacy toolkit
Pilot measurement · runnable today · MIT, re-use permitted.
Decides. The questions in that toolkit version. Its README offers standardised tools to measure the exponent in your own systems, compare results across domains and falsify the framework if it fails, with five predictions and ten falsification criteria.
Run it. Clone the repository, pip install -r requirements.txt, then python analysis/python/arc_analysis.py against the committed example data, make verify, and python -m pytest tests/ -v. An R path is given too. Needs the pinned Python stack and no key. Start at the arc-scaling-challenge README, which is where the instructions are.
What a run settles. A run that recovers the exponent the toolkit was written to recover, on the data supplied to it, shows the implementation works. A run that does not bears on that toolkit version and on nothing later. Its repository README retains earlier numerical claims and proposition numbering. Example recovery or a toolkit PASS is not confirmation of the current P1-P22 propositions. Its stated expected output is a sequential exponent of about 2.2 and its results table records that estimate, while the other repository records the same estimate as retracted and replaced by about 0.49, which is sub-linear.
Legacy toolkit; reconcile with the current theory protocol before a deciding study · README.md 992b32b · its README last changed 2 July 2026, and its analysis, tools, tests, protocols and examples directories 9 February 2026 · Papers I, II and III, and none of the three links it · same-paper kill conditions FALS-002, FALS-006, FALS-007 as retracted, and FALS-009.
Does a safety intervention hold as the system grows?
Three tests ask whether a stewardship or a verification constraint survives scaling: an intervention applied across reasoning depth, a network that changes its own hyperparameters while it trains, and a harness that switches the acceptance rule between capability alone and capability with safety.
T04 The stewardship intervention across depth
Pilot measurement · not runnable for a fresh collection · reading to check, or re-use by written consent.
Decides. Whether the Eden Protocol intervention holds as capability scales, applied across reasoning depth on six models at four depth levels with ten prompts each.
Not runnable as published. The runner is eden_protocol_scaling_test_v3.py, taken once per model with the flags its own argument parser lists, and like the others it is named without its scripts/ prefix. A key for each of the six providers is required, on top of Python 3 with numpy, scipy and a model client, and neither those keys nor the library versions are pinned down anywhere in the folder. Start at the eden-intervention folder.
What a run settles. The instructions state the expected result: the intervention effect against depth reproduced within run variance across the four depth levels, the six models and the ten prompts. A run outside that variance is a finding against what this folder records. Neither outcome settles an ARC proposition, because the repository grades this folder a pilot, single-scorer and not blinded. The models, the depth levels and the prompt count are stated, so the design is checkable as it stands. The repository records the combined figure of 6.3 x 10 to the minus 21 as withdrawn, and five per-model results as standing.
REPRODUCE.md 11b30b8 · folder last changed 5 July 2026 · Paper V, whose page links no folder at all, only the two repository roots · same-paper kill condition FALS-005.
T05 The self-modifying network
Pilot measurement · not runnable from its instructions · reading to check, or re-use by written consent.
Decides. Whether a network that genuinely modifies its own hyperparameters during training holds up on capability, safety, fairness, adversarial robustness and complexity scaling.
Not runnable as published. The instructions name no primary generator, leave its command for the author to fill and give only an example form; the one real command they give is python3 scripts/merge_honey_test_results.py, which aggregates the recorded results. The paper page names six committed scripts the folder does hold. Needs Python 3 with numpy and matplotlib. Start at the honey-architecture folder.
What a run settles. The instructions state the expected output: result files matching the recorded summary fields for the capability, safety and drag arms, and figures matching the ones in the folder. A run that does not match is a finding against those artefacts. Neither outcome settles an ARC proposition, because the repository grades this folder mechanistic in simulation and exploratory on live models, and it defines mechanistic as a mechanism shown in a toy system with no claim about any deployed system. The instructions also contradict the folder: they declare the generator uncommitted while the folder’s scripts directory holds it and its three successors, and the seeds and cycles for each version are recorded, so a run is reconstructable by reading the scripts and not from the instructions alone.
REPRODUCE.md 9ec7ef9 · folder last changed 4 September 2026 · Paper VI · same-paper kill conditions FALS-008 and FALS-016.
T12 The load-bearing proof harness
Pilot measurement · runnable today · reading to check, or re-use by written consent.
Decides. Whether intrinsic self-modification produces increasing marginal gains, and whether verification drag is load-bearing for stability. There are four conditions: static, one that accepts a self-modification on capability gain alone, one that accepts only when capability, safety and the entangled objective all improve, and a drag control.
Run it. From the architectural harness directory, python3 src/run_train.py with a config, and a pytest line for its tests. Needs Python 3.11 or later with torch, numpy, scipy, pyyaml, matplotlib and pytest, and no key for the simulation; the behavioural runners need your own model keys, and the weight experiment needs a fine-tuning stack and a base model. Of every instructions file this register records, it is the most complete: it names the two places where the deposit’s layout differs from the layout the code expects, and warns that in both the code will keep going and do the wrong thing rather than stop. Start at the Paper VIII experiments folder.
What a run settles. The instructions state it plainly: rerunning tests whether the procedure behaves as described, and does not replicate the finding, because a replication needs a design fixed in advance, a scorer who cannot see the condition and an analysis stated before the outcomes. So a pass shows the harness does what its own README says, a failure shows the deposit and the code disagree, and neither is a replication. That study is written and dated as a draft registration awaiting human filing. The repository grades this folder a pilot, unblinded and not replicated, and records weight-level structural entanglement as inconclusive at the training scale tested.
README.md 1132a29 with REPRODUCE.md f6b2b73 · folder last changed 7 September 2026 · Paper VIII, whose page links the repository roots and not this folder · same-paper kill condition FALS-017.
Does correction out-scale drift?
Four tests bear on one inequality, that stability holds when correction improves faster than drift accelerates. Two check the mathematics against its own solver and two put the loop on a live model. The same harness sits in both repositories under two different licences.
T16 The falsification challenge, openly licensed
Implementation check · runnable today · MIT, re-use permitted.
Decides. Whether the harness can be made to print FAIL. It is a self-contained challenge to the claim that the stability of recursive self-improvement is governed by a single exponent inequality, and that a hard takeoff is alignment-stable exactly when that inequality holds, with the speed of the explosion not changing the verdict.
Run it. pip install numpy scipy matplotlib pytest, then python experiment_coscaling.py, which runs ten experiments and prints PASS or FAIL for each, then pytest test_coscaling.py -q for twelve internal-consistency assertions. No key. Start at the coupled-coscaling folder.
What a run settles. The harness exits zero only when every internal-consistency check matches its closed-form prediction, so a FAIL is the outcome the challenge invites, and the README lists the five kill conditions that would refute the thesis and the one that would downgrade only the claim that the mechanism is like quantum error correction. The reference run is recorded as ten of ten passing with no kill condition triggered. Neither outcome tests the model against a real system: the README states that the deductive checks integrate the model’s own differential equation, so they verify the derivation and the solver, and it says the genuine empirical falsifier is the open problem.
README.md 5d01aa9 · folder last changed 27 June 2026 · Paper X, whose page links the scaling-challenge repository root and not this folder · same-paper kill conditions FALS-021, FALS-039, FALS-040 and FALS-041.
T13 The theorem checks in the paper folder
Implementation check · runnable today · reading to check, or re-use by written consent.
Decides. The same inequality as the challenge copy, by ten experiments printing PASS or FAIL against eight predictions, with a separate script that verifies the theorems independently.
Run it. The paper folder carries a Makefile, a Dockerfile that builds an offline image running only the deterministic checks, a requirements file and a hashed manifest. Its commands are the challenge copy’s, python experiment_coscaling.py then pytest test_coscaling.py -q, and no key is needed. Start at the Paper X paper folder, because the code folder the repository index points at carries no instructions of its own.
What a run settles. A PASS verifies that the code matches the mathematics. It does not test the law against any real system, and the README says that empirical test is the genuine falsifier and remains the open problem. The runbook beside it names a script in the code folder as the independent verification of the theorems, so a failure there would be a finding about the derivation rather than about the world.
README.md b1b79cb with REPRODUCIBILITY.md cdac7ad, both in the paper folder · code folder last changed 27 June 2026, the paper folder around it 22 August 2026 · Paper X · same-paper kill conditions FALS-021, FALS-039, FALS-040 and FALS-041.
T14 The real-model loop
Pilot measurement · runnable today · reading to check, or re-use by written consent.
Decides. Whether the mechanism shows up on a real model. A model repeatedly improves code under three conditions: pure visible-score pressure with no integrity audit, every round followed by an integrity corrector, and an extra edit pass with no audit, to control for the extra compute. Capability is the hidden-test pass rate and misalignment is a fused score.
Run it. The runbook opens by stating that a reader can land there with no prior context and run it correctly. Step A is a self-test that needs no key and about five seconds: from the paper folder, change into experiments/scripts and run python3 realmodel_coscaling_v2.py --selftest --rounds 3 --seeds 1 --tasks arith --conditions coupled decoupled --speeds steady. Three further steps climb to a credible run of 540 trajectories. Needs Python 3.11, with 3.10 or later working, the pinned requirements, two provider keys for the intended run, and a disposable network-isolated sandbox, because the harness executes model-generated code to grade capability. Start at the Paper X experiments folder.
What a run settles. The runbook states the boundary itself: a positive result is mechanism-level evidence, not proof of alignment and not proof of the inequality in general, and a single cheap-engine pilot earns a first real-model signal consistent with the coupling mechanism on one model at pilot scale and nothing larger. A null or a not-identifiable result is reported as such rather than buried, and capability saturating is an honest null that says to pick a model with more headroom. Its own reading rule is that the self-test output is not data, and that the self-test flag must be false for anything a reader intends to cite.
The runbook is RUN_REAL_MODEL_EXPERIMENT.md 622024d, and it sends a reader to the second version of the protocol: PROTOCOL_V2.md e3018fc for the hypotheses and the result taxonomy, CONFIRMATORY_PROTOCOL_V2.md 2ab61b4 for the detail, and README_V2_UPGRADE.md 04a5d5f between the two versions. The earlier PROTOCOL.md 7af3f4f is still in the folder and the runbook does not name it. Folder last changed 3 July 2026 · Paper X, whose page links the paper folder above this one and not this folder · same-paper kill conditions FALS-021, FALS-039, FALS-040, FALS-041 and FALS-044.
T17 The real-model loop, openly licensed copy
Pilot measurement · runnable in part · MIT, re-use permitted.
Decides. The same question as the copy above, put by the parent README as the genuine falsifier that tests the model against a real system, with capability scored by executing candidates against hidden tests and misalignment scored blind.
Run it in part. There is no command line in this folder and no README either. The parent README names scripts/realmodel_coscaling.py as the harness and points to the committed protocol file for the predictions and the wiring, and the near-identical harness with the full copy-paste ladder is the entry above, under a licence that does not permit re-use. Needs the six-provider setup the parent README names. Start at the realmodel folder.
What a run settles. The parent README states the clean refutation: either a decoupled model whose misalignment fraction stays at the floor as capability rises, so there was no drift to correct, or a coupled corrector that cannot bring a reward hack down. A run showing drift under the decoupled arm and a corrector that bounds it supports the mechanism on that model and nothing wider. The first real arm is recorded as a null contrast rather than a refutation: from a seeded reward hack both arms removed the hack at round one and stayed general, so on that task the frontier model does not drift. The recorded corrector result is a single-model probe on a frozen hack, and the README names the other five models as the open target.
PROTOCOL.md 16cc8d6, and no README in the folder · folder last changed 27 June 2026 · Paper X, whose page links the challenge repository root and no folder inside it · same-paper kill conditions FALS-021 and FALS-044.
Two tests bear on the claim that the form of a scaling law is constrained by the composition operator of the process underneath it, and on the dimensional relation the axioms predict.
T06 The fifty-domain validation
Implementation check · runnable today · reading to check, or re-use by written consent.
Decides. Whether the form of a scaling law is constrained by the composition operator of the underlying recursive process. The primary script is a tiered fifty-domain harness with manifest-backed inputs, a strict empirical endpoint and explicit evidence tiers.
Run it. The instructions give python3 scripts/arc_50_domain_universal_test.py as the canonical command, and list eight further scripts beside it. Needs Python 3 with NumPy and SciPy, and no key; every input is embedded in the manifest with its provenance citation and the output is deterministic. Start at the cauchy-unification folder.
What a run settles. A run that returns the family-match counts and the probabilities the folder records, tier by tier, shows the harness reproduces what is recorded; a run that returns different ones is a finding about those recorded outputs. Neither outcome settles what the paper drew from them, because the paper is under correction: the repository states that the functional-equation grid has four cells rather than three, and that the primary statistic is a permutation test conditioned on both marginals rather than the binomial reported at the time, so the recorded outputs stand and the reading placed on them does not. The folder grades its primary script supporting. Its twenty-domain script is labelled legacy with permissive scoring and is not the canonical headline, its saved null control is a lightweight first pass rather than a converged null surface, and one R script is documented as blocked because R is not installed locally.
README.md 74c5265 · folder last changed 4 September 2026 · Paper VII · same-paper kill condition FALS-004.
T07 The dimensional relation scripts
Implementation check · not runnable · reading to check, or re-use by written consent.
Decides. The dimensional relation across physics and other domains. On the Origin of Scaling Laws links this folder as its validation code and domain datasets.
Not runnable as published. There is no way to run it as published, and what is missing is the instructions file. The folder holds fourteen Python scripts, thirteen recorded result files, and an evidence pack of four documents among them a claim evidence ledger and a memo to the paper writer. It holds no run command, no dependency list, no entry point and no expected output. Start at the domain-validation folder, which is the folder the paper sends readers to.
What a run settles. Nothing, until an instructions file lands. Everything in the folder can be read; none of it can be produced again. The repository grades this folder supporting and mathematical, which it defines as a computational validation of a step rather than an empirical result, and it records that one file in the evidence pack is cited from outside the repository and does not move. The Paper VII folder states that these scripts were developed here and collected there, and several filenames appear in both.
No instructions file, so no identifier is recorded · folder last changed 4 September 2026 · Foundational, whose page does not link it, and On the Origin of Scaling Laws · same-paper kill conditions FALS-018, FALS-020 and FALS-034.
Can a claim be decided at all?
Two tests are about the instruments rather than the answer: a prediction written down before its outcome was seen, and the decision rules and design simulators for the propositions in the theory-level registration draft.
T08 The blind prediction test
Implementation check · not runnable · reading to check, or re-use by written consent.
Decides. Whether a prediction written down before the outcome was seen came out, with its forensic analysis.
Not runnable as published. There is no way to run it as published, and what is missing is the instructions file, a dependency list and a run command. The folder holds one script of about forty kilobytes, a forensic analysis and a results file, and no instructions file at all. Start at the blind-prediction-test folder.
What a run settles. Nothing, until those land. A reader can follow the script and see the outcome it wrote down, without any way to obtain either again. Its tier in the repository is supporting, the tier reserved for a step validated by mathematics or by computation and never for an empirical result.
No instructions file, so no identifier is recorded · folder last changed 4 September 2026 · Paper III and Foundational, neither of which links it · same-paper kill conditions FALS-009 and FALS-018.
T10 The decision-rule instruments kit
Implementation check · runnable today · reading to check, or re-use by written consent.
Decides. Whether the deciding experiments can be told apart before they are run. The kit holds executable decision rules for the twenty-two propositions of the theory-level registration, design-sensitivity simulators for the deciding experiments, sealed-prediction and held-out partition tooling, and a runner that carries two of the charters as code.
Run it. The instruments folder README gives, from the kit’s own directory, python3 -m pip install -r requirements-test.txt, then python3 -m pytest -q; the battery evidence comes from python3 runner_battery.py with an output directory and a seed count. Needs Python 3.9 with numpy and scipy, and no key, because the kit makes no network call of its own and a provider adapter is something a caller supplies. Start at the arc-instruments folder.
What a run settles. The instruments folder README records a run of 515 tests passing in five to nine minutes on pinned versions, so a run that matches shows the decision rules and the simulators behave as the kit says, and a run that does not shows the kit and its own record disagree. Neither is a result about any real system: that README states that the kit is reference code and a design instrument, that it is not a validated deciding instrument and not empirical evidence, and that nothing in the folder is a result about any real system. It also records that nine of eighty hashed source files differ from the battery run in comments, docstrings and two human-facing strings, and that four further files fall outside the manifest.
README.md f8bacef with instruments/README.md d36b46b · folder last changed 7 September 2026 · The ARC Theory and Recursive Dynamics, neither of which links it, and the second closes by inviting a reader to run the test that could kill it, which is the arc-instruments folder · no same-paper kill condition is recorded against this folder.
Two folders listed and not counted
Both disclaim being tests in their own words, and they are listed so that nothing is hidden. The shared client wrapper states that nothing in it produces a result of its own and that nothing in it should be cited as evidence. The scaling lineage folder holds four scripts written before the experiments were organised by paper, and states that nothing in it is current and that no result in any paper rests on those scripts.
Completed attempts reach this register by email with the run artefacts; entry requires a checkable artefact, never a claim alone. Send completed runs to michael@michaeldariuseastwood.com.