Epoch 1, frozen 2026-09-14. Every cycle count and score on these pages comes from epoch 1, scored under verifier hash de5bec22 with the retired rule that charges a coefficient the cheaper of a shift-add chain and a hardware multiply.
The 14 decisions from DESIGN.md, written before any code existed. Each gives the original context, then what the working system does now and what the choice cost; the tag says whether it survived the build (3 were revised).
The problem is quantization, not coefficient prettiness#held up
Before the build: In floating point, h·b constant-folds and 1/3 costs the same as 0.25. The premise only survives in fixed point on an FPU-less MCU, where a power-of-two coefficient becomes a shift. Scope narrowed to that case.
Before the build: Dyadic rationals are closed under addition and multiplication, and Σ b·c² = 1/3 is not dyadic. So the objective is to minimize non-dyadic multiplies subject to order, and the verifier code DYADIC_IMPOSSIBLE keeps the search out of the empty region.
As built: Kept, and it shaped the search space. A is snapped to dyadic values but b is solved exactly over the rationals, because snapping b would run into this very theorem. The verifier rejects all-dyadic order-3 claims without evaluating them (tests V5 to V7).
Static cycle counting, not simulation, not hardware#held up
Before the build: The inner loop is branchless straight-line code, so summing instruction costs gives an exact count and a real worst-case figure, and host load cannot disturb the metric.
As built: Kept, and sharpened: the count is analytic from the tableau, with no compiler or disassembly in the loop. One hand-counted ARMv6-M sequence, reproduced exactly by a test, ties the model to hardware, and emit_c exists for a one-off human cross-check.
Cortex-M0+ primary, AVR advisory, two M0+ multiplier variants#held up
Before the build: The M0+ has no FPU, divide or long multiply, so fixed point is forced. Running a 1-cycle and a 32-cycle multiplier model costs nothing and shows whether hardware awareness changes the ranking.
As built: Kept, and under the frozen epoch-1 rule the ranking does change: it prices rk4 cheaper with the fast multiplier and rk38 with the slow one (the anchor result, which also gives the compiled trace's counts for the same pair). After a live candidate was rejected on an infinity in the AVR column, verification was restricted to the primary-model columns.
Q15, wrapping semantics, overflow as a rejection#revised in build
Before the build: Q31 would have to be synthesized on the M0+, and saturation needs a compare and branch that breaks exact counting. Overflow at 2× amplitude is a verifier rejection, which makes it a property of the method rather than a runtime cost.
As built: Revised on one point: nothing wraps. A value outside int16 raises Q15OverflowError and becomes a verifier rejection. One addition the spec missed: rc_thermal's derivative times its state scale leaves Q15 range, so derivatives carry a per-problem power-of-two scale (DERIV_SCALE, 1/8 there) that the step undoes through h. Floor rounding turned out to be an experimental variable in its own right (key finding 2).
Classical optimizer in the inner loop, LLM in the outer loop#held up
Before the build: A six-parameter space has gradients, so CMA-ES does better than an LLM mutation operator at no cost. The LLM decides what to search and interprets what came back.
As built: Kept. When order-4 islands produced nothing (an exact order-4 b is rarely solvable over a dyadic A), the fix was a projection fallback in the optimizer, not more LLM. The outer loop grew hypotheses and a literature loop.
Search/held-out split, enforced structurally#held up
Before the build: The optimizer has no code path that reads HELDOUT_SET, and the held-out gap is a dashboard metric so it cannot rot unnoticed.
As built: Kept literally: a test walks the optimizer's import graph to enforce it, and the D5 drill shows the gap collapsing when the optimizer is fed the held-out set (testing). The gap is also a caveat on the best numbers (key finding 1).
Before the build: Descriptors are stage count and cycle-cost bucket, which gives a table of results rather than a single champion.
As built: Kept unchanged. The findings site's explicit page and cell pages are built from these grids, and a cell's incumbent is what tier assignment compares against.
Before the build: A 2-stage method gets twice the steps of a 4-stage method for the same cost, and equal-h comparisons are the most common route to a wrong conclusion.
As built: Kept, and it frames every result on the key findings page: the rank flips and the efficiency frontier only exist at equal budget.
Fixed resource limits plus a pause watchdog#held up
Before the build: Low cpu-shares and docker pause on contention keep the run out of the way in about forty lines, with no dynamic allocation and no GPU.
As built: Kept, and grown a little; the host layer lists what the watchdog does now. Thresholds live in config.json rather than in code.
Credentials outside the container, harness mounted read-only#revised in build
Before the build: If the agent can write the verifier, the shortest path to a high score is editing the scorer. The token was to be scoped to rk-work and rk-findings, with the 403 on rk-harness as an acceptance test.
As built: Half kept. The read-only mount and pinned hash stand, but the token scoping did not survive: the owner's token could write everywhere, and the 403 probe passed for the wrong reason. The credential now never enters the container; a filtered env file and host-side pushes make that independent of token scope.
Auto-publish numbers, never claims#revised in build
Before the build: The site emits values with mechanically assigned tiers, so a wrong result is a wrong number in a table, not a claim that needs retracting.
As built: Amended by the owner, with the guard intact. The findings site also publishes model-written interpretations and literature digests, labeled as such and passed through a softener that replaces priority-claim words. The banned-words guard still fails any page it rejects, and it blocked real builds until the softener existed.
The encourager may change direction but not stop#held up
Before the build: Before a calendar date it can only redirect, widen, hypothesize or advance phase. A set-and-forget system with no calendar runs until the operator gets bored.
As built: Kept. PACKAGE (re-verify everything, no new directions) opens 2026-11-20 and FREEZE 2026-12-05, property-tested over random states and exercised through the real clock path.
Before the build: If derivative evaluation swamps coefficient arithmetic, the thesis is dead, so find out in week one rather than month three.
As built: Kept, and the verdict was stored as it came out, "mixed" (key finding 3 has the numbers).
What was deliberately cut
Adaptive step size and Newton-iteration implicit methods break the execution-time
certificate that hard real-time needs, so they are wrong for the target whatever they
cost. Order above 4 and linear multistep methods multiply the search space with no
reason to expect a larger quantization effect. Rosenbrock methods remain the natural
second project. The build added one item: round-to-nearest is measured as a
counterfactual on the key findings page (finding
2) rather than searched over, because changing the arithmetic changes every score in
the archive.
Two of those cuts have since been revisited, on terms that narrow the real-time
objection. The adaptive class uses a division-free controller and books each attempt at
its worst-case cycles, though the number of attempts still depends on the data. The
implicit class fixes its Newton iteration count so each step costs the same. Both are
measured outside the scored archive, on the findings site's
adaptive and implicit
pages.
Related work, and where the gap is
RKTK (Zhang, 2019) already runs unstructured numerical searches over Butcher order
conditions and holds a stage-count record at order 10, so numerical tableau search is not
the contribution. That line of work optimizes order, stage count and error constants in
exact arithmetic. It does not price coefficients against a hardware cost model or measure
end-to-end error in fixed point, and that gap is narrow enough to finish.
Two things are different here. That work is about floating point at low precision under
round-to-nearest or stochastic rounding, while this run is fixed-point Q15 with directed
floor rounding, where every inexact product moves the same way instead of scattering about
zero. And that work analyzes fixed methods under an arithmetic, while this run searches the
tableau space against the bias. The stagnation result is a check on this harness rather
than a rival to it: finding 3 measures the same
turn-up in a different arithmetic, which is what a working measurement of a known effect
should do. The run's literature loop keeps collecting adjacent work, and its digests are in
the findings site's research log, labeled as
model-written.