#93 kickoff: what four papers changed, the operator's questions answered, and a 3-day recursive program that is ready to launch

0. TLDR

• Weight-damage question settled at the mechanism level: our runs sit below the bf16 per-weight realization floor (0.195-0.391 percent relative); RL updates are KL-leashed, off-principal and spectrum-preserving, so base capabilities are structurally protected while the codec is unbiased. The one collapse we ever saw (PowerSGD) is exactly what the theory predicts when a codec injects biased, coherent error.
• One of our own ideas was refuted by the papers: "send only the coordinates that changed" is unsound (the visible sparsity is a precision artifact). The sound replacement, a geometry-derived safe mask both ends compute from the base checkpoint, cuts anchor sign traffic ~1.4x with zero mask bytes on the wire.
• The controller we designed turns out to be the published DCMDP dual variable in disguise; we adopted its form (never target zero, bounded multiplier, dual ascent) and its ratio-free per-token penalty as CVC mode (b), which stays numerically alive exactly where importance sampling is dead on PRF.
• The gap decomposes: a 13.9-nat static codec artifact (present at step 1, untouchable by any optimizer lever) plus a +0.28-nat creep over 600 steps (the real target). The dense control's gap settles at 0.0002 nats, proving the escalation loop from the LR paper is not active at our learning rate.

Final status, 2026-07-28. The program is complete.

1. The operator's questions, answered (committed before reading, corrected after)

Protocol: answers were written down first from current understanding, then two dedicated subagents read the four papers in full, then each answer was re-checked. Changes are flagged.

Q1. Does PRF distort the weights more than dense training does?

No evidence that it does, and the papers explain why the fear is misdirected. "PRF accumulates extra movement" was a statement about the measured policy KL, not the weights. The codec-view KL mixes real policy drift with the codec's distortion of the measurement itself; the probe (section 4) is the instrument that separates them, and until it runs the honest bound is "at most ~60x dense in the codec's own view, far less in the real view". On the weights directly: movement is tiny in every regime (cosine-to-base ~1.0, relative change 0.03-0.13 percent), and the papers add the decisive detail that this is below the bf16 realization floor of 0.195-0.391 percent per weight, so most individual weights are bitwise unchanged. Capability evidence agrees: val held 0.451 to 0.661 over 600 steps and the 10-benchmark OOD suite showed parity with dense at step 100.

Refined after reading: the structural protection (KL-leashed, off-principal, spectrum-preserving updates) is conditional on the update stream being unbiased. Unbiased codecs (PRF, stochastic rounding) keep the protection; a biased coherent codec (PowerSGD held-Q) defeats it silently at unchanged update magnitude, which is exactly the early-layer-shift collapse we measured. Consequence: monitor geometry (spectral shift, principal angles), not weight norms.

Corrected bookkeeping: the train-inference gap series rose 13.88 to 14.66 but 87 percent of that is the sampler sharpening; the training-view component crept 14.46 to 14.74 (+0.28). And "RL updates 5-30 percent of parameters" is probe-dependent: bf16-aware probing revises it to ~46 percent changed for our 1.5B math class.

Q2. How do we exploit the RL-update properties (sparse subnetworks, off-principal movement)?

Three sound mechanisms adopted; one of our pre-reading ideas withdrawn.

• Withdrawn: discovering the active subnetwork from the sign-EMA and sending signs only for it. The papers show off-subnetwork gradients are not zero (sub-ULP micro-updates plus a geometry routing bias), so changed-coordinate heuristics mistake a precision artifact for structure.
• Adopted (phase 2): safe-mask sign traffic. Both ends compute, once, from the shared base checkpoint: M_safe = low-magnitude weights plus everything outside the principal entries. Published evidence: RL restricted to this ~70 percent mask tracks dense accuracy and KL trajectory; principal-only training is the worst arm. Zero mask bytes on the wire; 193 MB to ~135 MB per anchor fire, and optionally freezing the other 30 percent makes "principal weights cannot move" a hard guarantee.
• Adopted (phase 2): bf16-changed delta encoding for the periodic dense refresh: ~54 percent of a trained 1.5B math checkpoint is bitwise unchanged from base, so a refresh ships as bitmap + changed values: ~1.8-2x lossless, stacking with quantization.
• Adopted (laptop, this program): geometry monitors as the collapse early-warning: per-layer normalized spectral shift and principal angles from checkpoints, targeting exactly the early-layer signature weight norms cannot see.
• Low-rank verdict: post-hoc low-rank compression of realized updates is ruled out (99+ percent full-rank). In-the-loop low-rank (our rank-1 RELEX anchor correction) is endorsed short-run because trained adapters find off-principal directions; phase 2 schedules a 600-step RELEX on/off arm, and low-rank must never be seeded from principal directions.

Q3. Is unbiased activation compression a regularizer or just a cost?

The evidence so far favors "benign, possibly mildly regularizing" for unbiased codecs and "destructive" for biased ones. OOD dose-response: the compressed policy matched dense on all 10 benchmarks at step 100 and beat dense@150 on two, despite a ~1000x codec-view KL ratio. The #89 dropout arm (the classic noise regularizer) was benign; PowerSGD (biased) collapsed. The papers supply the mechanism (unbiased noise leaves the geometry routing intact; biased error defeats it), and the controlled test is now scheduled where it belongs: round C compares the winner to the dense control on the OOD suite at matched dense-view training KL, probe-measured. Pre-registered expectation: parity or slight codec advantage.

2. What the four papers say (and what we adopted)

3. Fresh data: the baseline pair

Dense control (live, protocol-identical): reference KL 0.0074@288 and concave; its train-inference gap settles at ~0.0002 nats with E[rho] = 1.0000. The gain G(t) between the curves grew 17 to 60 and is decelerating; whether the excess is real dense-view drift or mask adaptation is exactly what the probe measures in round B. Baseline gate card at step 100-120 (what every round-A arm must beat): reference KL 0.156-0.203, gap 14.24 nats, E[rho] 0.0014, training score 0.63-0.68 with slope 0.0032/step, entropy 7.81.

4. The program (issue #93, plain language)

Baseline to beat: the #90 PRF exact-k 600-step run. One clarification the operator asked for: the every-25-step dense pass is a probe: it recomputes the batch's log-probabilities once with the codec switched off, measurement only, and never touches the weights. It feeds an adaptive coefficient on the always-on reference-KL leash (a dual-ascent controller with a nonzero setpoint tied to the dense control's curve). The channel that touches weights on a cadence remains the anchor (sign of a gradient EMA every 20 ticks, modeling the real-world slow sync).

Rules: validation only in round C (gate cells use the free training reward slope); checkpoints only in round C (R2 sink); every decision rule is pre-registered in the issue; anything ambiguous goes to the analyst verdict, not a relitigated debate. Full equations for all nine mechanisms are in the issue body, section 4.

5. Implementation status (branch 93-mismatch-control-kit)

Suite: 281 tests pass at HEAD f563c3cd; the branch is pushed to origin so any cell launches on the box with one command (DRY_RUN=1 echoes the resolved config first). A single short verification pass over the final wiring returned LAUNCH_READY with all five checks passing (default-off safety, probe correctness, controller delivery, launcher contract, within-step identity). Known caveats recorded in the issue: the round-B/C setpoint table must be baked from the finished dense control before b1/c can launch (the launcher fails loud without it), and the step-600 val must be backfilled from train.log per the known WandB teardown race.

6. The 3-day recursive loop and who runs it

A dedicated planning subagent published the plan of record into issue #93 (deep tier, labeled awaiting:approval). It is ONE long-running recursive trial-and-error experiment, up to 3 days on exactly one H200, under a strict loop: run, observe, decide, next run, with every round designed from what the previous round found. One box serves every consecutive cell; no teardown between cells.

• Minimum 100 steps per run before judging (anchor properties need a few fires); the RN control's early stop at 60 steps is the only sanctioned cut, and only on an unambiguous signal.
• Validation only on the final method (round C); gate cells are judged on the free training reward slope plus codec-view and probe metrics.
• Verification is one short final pass over round C only, never per-stage gates; deeper testing happens by actually running the experiment.
• Pre-registered decision rules from the issue's decision tree; one judgment fallback: on an unforeseen outcome the analyst writes REVISE, the planner amends only the next step, and any new spend goes to the operator.
• Laptop work runs during GPU time: the geometry-monitor script (I7) and the two checkpoint measurements (M1 bf16-changed fraction, M2 geometry on PRF vs collapsed PowerSGD checkpoints) execute as Workflow fan-outs while round A trains, and M2 feeds the analyst's collapse read.
• Completed inputs treated as settled: the two paper-panel subagents (RL mechanics, optimization); their verdicts are baked into the issue and this report.
• Budget: ~28-36 GPU-hours nominal, hard backstop 44; clean negative is also a PASS (if no arm beats the incumbent gate, the program closes at round A having established the incumbent's optimality under this budget).

Round A ran to completion on 2026-07-25: a1, a3, a4 and a5 to 120 steps each, a2 stopped at step 60 under its pre-authorised kill. Every threshold below was committed in writing before a4 and a5 produced a single step, so none of it can have been fitted to the results.

The blind-committed lexicographic criteria produce no winner. Eligibility leaves the incumbent, a4 and a5; the drift veto then eliminates a4 and a5. a3 is excluded on wire budget by 0.5 bits, an overdetermined exclusion since it also fails both objective clauses. The incumbent survives its own vetoes by construction and fails the objective at 3.7x the settling bar.

a3 and a5 are complementary failures. a3 clears every safety veto and moves the objective nowhere. a5 moves the objective decisively and fails two vetoes. No arm clears both, so the pre-registered decision ladder has no matching row and the registered judgment fallback governs: escalate to the operator, launch nothing.

The program's registered success criterion is a train-inference gap that settles. Four compressed arms rise. One falls.

Named series direct-labelled; a1, a2 and a3 drawn as one muted band. Palette validated for colour-vision deficiency (worst adjacent pair ΔE 9.2 deutan, 27.6 normal).

The fall is genuine codec convergence, not a lower instrument offset: a5's training-view log-perplexity fell 9.9623 to 4.4848 while its sampler held near 0.19, and the gap is essentially the difference between the two throughout. FRLR's rank-48 basis warm-starts into an accurate reconstruction.

Only the three arms whose reference KL is comparable in level are drawn. a1 (2.284 nats) and a3 (0.923) are excluded because each carries a large stochastic-rounding view offset, so plotting them on one axis would repeat exactly the incomparable-levels error documented in section 10. a4 sits at 0.206, close to the incumbent. Series start at step 10 to exclude a5's warm-start transient, which peaks at 2.798 nats at step 2.

The veto fired on a leading indicator (slope), not a realised harm (level). a5's reference-KL level sits below the incumbent's in every window: 0.375x at 61-80, 0.584x at 81-100, 0.838x at 100-120, and 0.980x at step 120 exactly, with the fitted crossing about step 122.

Whether that acceleration saturates is not resolvable from 120 steps. The incumbent's own slope saturates after step 80 and its real 600-step trajectory is benign (0.19 at 120, 0.31 at 200, 0.45 at 300, 0.62 at 400, 0.91 at 600), nowhere near the 3-8 nat collapse band. An earlier draft of this analysis extrapolated a5's power law (exponent 2.65, self-consistent to 4 percent) to 3 nats by step 334 and stated it as fact; that was overclaimed from a 2.8x horizon extension and is recorded here as conditional.

Coherence, not magnitude, gates capability damage

a1 and a2 differ in exactly one environment variable, making a clean single-knob factorial. Varying noise energy 2.7x at zero bias moved drift not at all. Flipping to biased rounding at identical wire budget moved it 6.9x (z = +15). Provenance is unusually tight: one shared launcher branch, identical logical wire budget, and 6 of 7 confinement counters bit-identical at matched step 60.

The theory then predicted a5's failure

Token-IS at threshold 2.0 downweights about 87 percent of tokens, which is a strong constant-direction estimator bias. So the a1/a2 law predicts a5's drift failure from arms it was never fitted to, and three checks agree: the fitted exponent 2.65 is bias-like (constant-direction bias grows as t squared, unbiased noise as t, and step size moves only the coefficient); a5 shows about 25x the incumbent's drift per unit gradient norm despite 12x smaller effective steps; and updates dominated by the ~13 percent agreement-region tokens explain the falling gap and the rising drift simultaneously. This resolves what looked like a paradox: smaller steps producing more drift.

Most of the headline metrics were measuring instruments, not behaviour

This cost two near-miss decisions and is now quantified. The codec inflates the entropy reading about 43x: the dense control reads 0.1815 nats with its own sampler at 0.1792, agreeing to 1 percent as they must for an uncompressed run, while every compressed arm reads 7.79 to 7.94 against a sampler value of 0.18. Separately, 87 percent of a3's apparent gap-level disadvantage was step-1 offset measured with zero training done. a5's falling entropy read as textbook collapse and was nearly killed on it; Pinsker plus Fannes-Audenaert over the 151,936-token vocabulary caps any true policy-entropy change at 0.575 nats against an observed 2.24, so the drop was mathematically forced to be view movement.

CVC in cross-entropy mode cannot work by construction

The gap moves through rollout-view sharpening (-0.80 nats); the training view CVC-CE targets moves -0.035. Matched-window slopes agree within one HAC standard error in all five windows and a4's level is slightly higher. It bought nothing measurable (z = -0.91) for 82 percent worse drift. That is direct evidence for the registered DC-mode fallback, which is ratio-free.

Precision allocation is closed at deployable budget

Measured elasticity 0.494 nats of gap per e-fold of noise energy implies 6.5 to 8.5x the wire budget to reach the target. A pre-registered prediction that a3 would land near 13.6 nats failed (actual 14.99) for a structural reason: deletion and quantization are orthogonal variance axes (the deletion term is 18.948 for the incumbent, 2.116 for a3, 0 for a1), so a one-parameter fit through two arms cannot reach their mixture.

Recommended: one pre-registered 120-step probe, about 4 GPU-h, before committing 28 h to rounds B and C. The knob is rollout_is_batch_normalize, which defaults to False and which core_algos.py:2409 documents as normalising IS weights to mean 1.0. It restores about 6.03x of the observed 12.55x gradient attenuation. An earlier draft recommended widening the IS threshold instead; that was wrong, because only 0.33 percent of tokens sit at the cap while 88.4 percent are in the low tail, so raising it buys at most 1.11x.

Three riders fix round A's structural gaps: save checkpoints at 0/60/120 (round A saved none, so none of these five arms can ever be re-analysed); log actor-versus-reference KL through the anchor's existing paired dense replay, which yields a true-view drift channel essentially free and retires the codec-view ambiguity; and run step-120 validation plus two OOD benchmarks.

Ledger at the boundary: 20.1 of 100 GPU-h, about $67. Awaiting the operator's decision; nothing is launching.

Round A ended with no winner and one live lead, a5's falling gap. Two cells followed, each pre-registered before launch with thresholds hardcoded into the scoring script, because a bar that can be passed on the command line is not a pre-registered bar.

a5b: FRLR plus token-IS plus batch normalisation

Two things about that scorecard are worth more than the verdict. G2's slope clause is not a well-posed test, and this was demonstrated rather than argued: at 20 rows it read +0.001408, a fail at 2.8x, and adding step 120 moved it to +0.000358, a pass. The gap oscillates about 0.295 nats inside the 20-step window while the bar targets 0.010 nats, so a 20-step slope reports oscillation phase, not trend. It is recorded as passed and uninformative, and it would have been discounted had it failed.

And a5b validated at parity. Its terminal val is MATH accuracy 0.6593 against the incumbent's 0.6613 at step 150 and 0.6633 at step 300, while carrying 2.45x the incumbent's entire 600-step reference KL. The incumbent's own val wobbles across a range of 0.0120 between its four checkpoints and ends exactly where it started, so a5b sits inside its noise floor. The verdict's reasoning, that this was a bad trade under the rule against damaging the base model, was contradicted by that measurement. Section 13 explains why, and the explanation is not the one the verdict assumed.

a6 carries the same weighting as a5b on the incumbent's codec, and both cells run a dense probe: a forward pass on the same weights with the codec silent, no backward and no weight change. So probe/kl_dense is the policy's KL to the reference, and actor/kl_loss is that quantity seen through the codec.

a5b's "2.23 nats of drift" is 0.0168 nats of drift and a 133x measurement offset

This dissolves the val result rather than deepening it. a5b validating at parity was never surprising, because the base model was barely moved. No appeal to damage being collapse-only is required.

The two channels rank the arms in opposite order

In codec view a6 is the safest arm in the matrix, with a drift slope of +0.001404 against the incumbent's +0.002176. In truth it drifts more than a5b, and the ratio widens: 1.22x, 1.44x, 1.70x at steps 50, 75, 100. The mechanism is the one the probe was added to test. PRF exact-k draws each mask from a fixed stationary distribution, so its offset is roughly constant and the inflation falls, 134.6x to 14.3x. FRLR refreshes its basis every step, so its offset adapts and the inflation rises, 13.8x to 132.9x. Codec-view drift is a real quantity times a codec-specific, time-varying, non-monotonic factor spanning an order of magnitude in each direction.

a6 fails G1 at 0.4854 against the 0.6248 bar, 0.74x the incumbent, and it is not the onset delay that a5b showed. a5b closed from 0.71x to 0.98x across this span; a6 sits flat at 0.79x, 0.76x, 0.76x, 0.74x, 0.78x and does not move. Same weighting, same normalisation, opposite trajectory, so the deficit is an interaction rather than a property of the weighting alone.

a6's effective sample size is 0.0006, so a 128-sequence batch does the statistical work of about 0.08 sequences, with 99.97 percent of tokens in the low tail. rollout_is_batch_normalize divides by the mean weight, so at 0.0005 it amplifies the surviving mass by roughly 1600x to 2000x, and that mass rests on a handful of tokens. Gradient norm reaches 57.1 against the incumbent's 1.73, a factor of 33, still climbing, with a maximum of 248.8 excluding the step 1-3 transient.

The cause is the gap itself. The weight is exp(log πtrainer − log πrollout). At PRF's 14.1 nats that exponential is essentially zero for nearly every token; at FRLR's 4.4 nats the mean lands at a workable 0.17. The amplification factor is 1/mean_weight and mean_weight shrinks as the gap grows, so batch normalisation converts a large gap into a gradient explosion.

Health is impaired rather than degenerate: entropy flat at 7.8086, aborted ratio 0.0000, score still slowly rising, response length falling from 674.7 to 592.7.

The two finished cells jointly establish that the 3.2x gap reduction is FRLR's alone, since a6 reproduces the incumbent's gap to 0.8 percent while carrying the same weighting, and that the weighting is only viable because the gap is low. Neither shows the weighting is necessary. The corner of the design nobody has run is FRLR on its own.

a7 answers two questions in one cell. Does FRLR alone deliver the gap win with no importance-sampling estimator at all, and therefore no ESS, no truncation bias, no normalisation amplification and no onset delay? And does token-IS add true, codec-free drift? a7 against a5b is the same codec with the weighting on and off, with a dense probe on both, which is the one attribution that was otherwise impossible because the incumbent has no probe.

Four predictions are registered so the read is falsifiable: gap lands at 4.2 to 5.0 nats; learning clears 0.6248 without a5b's onset delay, so its score at 41-60 exceeds 0.3728; codec-free drift at step 200 comes in at or below a5b's 0.016754; and no rollout_is_* metrics appear at all, which is itself the check that the arm is configured as intended. Codec verified byte-identical to a5b by diffing the resolved config, so the only difference is the weighting.

Both probe cells ran a terminal validation, which round A did not. Put the gated quantity next to the capability it was supposed to protect.

Read the second and fifth columns together. a5b carries 7.63x a6's codec-view drift and has 1.22x its capability. The registered gate passed a6, whose drift slope of +0.001404 beat the incumbent's +0.002176, and failed a5b at 2.48x over threshold. The capability outcome is the exact reverse of both calls.

What a6's validation does not show

It is not damage below baseline. a6's val of 0.5391 tracks its own training score of 0.4932 at step 200, and both arms started near 0.357, so a6 improved on the base model and simply improved less. Calling it capability damage would overstate the evidence.

What it does show is movement without benefit. Taking the common starting score as a proxy for base val, which is a proxy because both cells ran with validation before training disabled:

a6 moved 2.66x further from the base model per unit of capability acquired. That is what an effective sample size of 0.00067 and a gradient norm of 64 actually cost: not a broken model, an inefficient one that spends weight movement without buying accuracy.

Neither recorded verdict changes. Both cells were scored against bars registered before their data existed, which is the only reason this evidence is worth anything.

a7 is the corner of the design nobody had run. It answers the two questions a5b and a6 left open, and at step 51 of 200 it has already settled the first.

The gap win is the codec alone, confirmed from both sides

a7 carries no importance weighting of any kind and reproduces a5b's gap to within 5 percent at every window, the same 3.1x reduction at the same 1232-bit wire. Together with a6, which carried the weighting on the incumbent's codec and reproduced the incumbent's gap to 0.8 percent, the attribution closes from both directions: token-IS contributes nothing to the gap and FRLR contributes all of it.

Token-IS caused the onset delay

a7 shows no onset delay at all, tracking the incumbent from the first window and reaching 0.979x by 41-51 where a5b sat at 0.730x and had not begun learning. Gradient norm tells the same story: a7 runs at 1.72 against the incumbent's 1.86, where a5b was suppressed to 0.62 by the IS weights and a6 amplified to about 30 by normalisation at a large gap. a7 is the only compressed arm in this program whose gradients look normal.

Nothing is settled until the registered window at 100-120 and the terminal validation. But no previous cell has had this combination: the full gap reduction, incumbent-speed learning, normal gradients, no importance-sampling machinery, at the incumbent's exact wire budget.

All three probe-bearing cells finished with a terminal validation, which round A did not have. Putting the gated quantity beside the capability it was meant to protect gives the program's clearest result.

Spearman(actor/kl_loss, val) = +1.00. Spearman(probe/kl_dense, val) = -1.00. Higher codec-view "drift" goes with better capability in every cell; higher real drift goes with worse capability in every cell. With n = 3 a perfect ordering arises by chance one time in six, so this is consistent evidence rather than proof, but the effect sizes are large and it matches the mechanism in section 13.

a7 carries 5.8246 nats of actor/kl_loss, inside the 3-to-8 nat band this program has treated as its danger zone, while holding the best capability ever measured here. Its real drift is 0.0082 nats and its inflation factor 710.2x. Any gate defined on that band would have killed the winning arm.

The val, stated carefully

a7's 0.6713 is +0.0090 over the incumbent interpolated at step 200, and the incumbent's own checkpoint-to-checkpoint spread is 0.0120. So this is not a clear win over the incumbent: a7's margin is smaller than the reference's own variability. The fair framing is the step count, since a7 reaches at 200 steps what the incumbent needed about 450 steps to reach, and it exceeds three of the incumbent's four checkpoints.

An observation that cuts against this program's own premise

a7's one real defect is that its gap stops settling. The mechanism points at a single existing knob: frlr_q_cadence=1 means Q is rebuilt every step and chases a policy that a7 moves faster than any prior arm, so the basis lags further as learning accelerates. a8 is a7's exact codec with the cadence raised to 20, mirroring the PowerSGD governance in which Q moved only at anchor fires.

At step 55 a8's gap is about 2x higher in level than a7's though falling fast, and its inflation at step 50 is 376.7x against a7's 71.6x, the opposite of what the hypothesis predicted.

The train-inference gap is driven by the reconstruction error the codec injects into the trainer's forward pass. Both codecs send exactly 77 numbers out of a 1536-dimensional activation. They differ in what those numbers buy.

Why it starts low: anisotropy, and specifically alignment

Transformer activations are strongly anisotropic, so the covariance spectrum decays fast and a rank-48 subspace aligned to the top eigenvectors captures far more than its nominal 48/1536 = 3.1 percent of the energy. PRF's coordinate deletion captures exactly k/H = 5 percent regardless of structure, because the coordinate axes have nothing to do with the principal directions.

The measurement confirms it is alignment and not the low-rank form. At step 1, where Q is a deterministic seeded frame and therefore a random subspace, FRLR is only 1.29x better than PRF (13.8794 against 10.7259), and the energy accounting says the two capture 5.0 and 4.9 percent respectively, which is a tie. By step 20, once the power iteration has fitted Q, the advantage is 2.98x.

Why PRF stays flat and FRLR does not

Why it climbs: estimator variance, not staleness

The obvious explanation is that Q goes stale between fits. Cell a8 refutes that. Freezing Q for 20 steps should make staleness worse, and instead the trend flattened by 13x:

a8's gap runs 11.7151 -> 8.0304 -> 6.8293, falling monotonically, where a7's rose to 8.1849 by step 200. So the mechanism is estimator variance in Q. At cadence 1 the basis is re-derived every step from a single batch's sketch with one power iteration, so it jitters, and that jitter grows as the policy's activations diversify. At cadence 20 the sketch accumulates over 20 batches before orthonormalising, so Q is estimated from 20x more data and stops jittering. a8's higher level is the flip side of the same fact: only 10 refreshes in 200 steps, so it converges from its random start more slowly.

What this rules in and out

An earlier section of this report attributed the climb to Q going stale. That reading is superseded by a8 and is corrected here rather than edited away. It was also nearly acted on: a step-55 read of a8 looked bad enough to justify killing the cell, and killing it would have destroyed the only evidence that identifies the mechanism.

The practical consequence points where the operator's architectural constraint already pointed. Anchor-owned Q is the limit case of what a8 tested, namely refresh rarely from a large accumulated sketch, and it has a second benefit: if Q lives in the anchor then its broadcast rides the slow circuit, which this program already does not charge to the wire budget, so the 1233.4-against-1232 discrepancy from the Q correction disappears entirely.

21. a8 scored: the codec-view inflation runs BACKWARDS between two arms that differ only in how often Q moves

a8's registered window is complete at 21 rows. It passes G1 and the G2 level and fails both slope clauses, and it is the arm to build on: best learning in the program, less than half the incumbent's gap, the flattest gap trend of any FRLR arm by 13x, the lowest codec-free drift, no importance-sampling machinery, wire parity to 0.1 percent.

The sharpest number in this section

a7 and a8 run the identical codec. The only difference is that a8 refreshes Q every 20 steps instead of every step. Their codec-view drift readings:

Codec-free, a8 is the cleanest cell measured: probe/kl_dense = 0.007006 at step 150 with a full-run slope of +5.1e-05, and probe/gap_dense averaging 0.000302 nats. So the codec accounts for a factor of 22619 in the measured gap: essentially all of the 6.83 nats is codec view, not policy divergence. The LR brake fired 0 of 30 probes, against a7's 1.

The confound I built in, restated so it is not forgotten. At cadence 20 over 200 steps Q gets only 10 power iterations against a7's 200, so a8 varies both view stationarity (intended) and total Q fitting (not). Its higher gap level against a7 (6.83 vs 5.08) is most likely that under-fitting rather than a cost of the slow cadence. Cadence 5 would have separated them; the operator's architectural instruction supersedes the question, so no cell is being spent on it.

22. Correcting myself: the unbiased test goes back in, because "sufficient" is not "exclusive"

In section 20 I concluded that estimator bias is "not the main driver" of the gap climb, on the grounds that a8 flattened the trend while still being the biased variant. The operator pushed back and asked why there would be no point testing the unbiased mode, given that the program's divergence and collapse had been attributed to directional bias in the first place. That pushback is right and my reasoning was bad in two distinct ways.

On the question actually asked, the program's strongest evidence is the operator's: the a1/a2 factorial killed the biased round-to-nearest arm at step 60 with 6.9x worse drift at z = +15, while the unbiased stochastic-rounding arm survived. One environment variable apart. And the two codecs in this program differ on exactly that axis: PRF exact-k is unbiased (constant 1/(1-p) gain, exact to 0.26%), FRLR as run is biased (a capped, detached, data-dependent gamma). It has never been isolated within FRLR.

The three runs, each changing one thing

Anchor-owned FRLR needed code, not a flag. The config validator rejected the combination outright on the stated premise that the codec "has no PowerSGD basis Q for the anchor to own". That is true of the plain PRF mask and false for FRLR, which does carry a per-boundary basis. And the mask codec had no ownership plumbing at all. Both landed with 25 new tests (159 pass, lint clean), including one that caught a real bug before it reached the GPU: the harvest gate read is_grad_enabled() from inside a no_grad block, where it is False by construction, so the sketch would never have accumulated.

23. a9 at step 20: one counter proves both halves of the anchor-owned Q instruction

The registered bar is scored at 100-120 and is not evaluable yet. This section records one thing only: whether the code does what it was written to do.

Why refreshes=7 is decisive rather than merely encouraging

The refresh counter is incremented in two places: the fast path's cadence branch, and the anchor's update. Under anchor ownership the fast branch is skipped outright, so the counter can only move inside the anchor. The model has 7 masked boundaries at pp_size=8, and one anchor fire refreshes all 7.

So the arithmetic confirms both halves of the instruction at once: the anchor IS the Q writer and the fast path is NOT. That is a much stronger check than "it did not crash", and it is exactly the property that could have failed silently, leaving an arm that reported itself as anchor-owned while behaving like a7.

The fail-closed assert not tripping is itself information

The engine asserts a non-empty sketch before refreshing. Passing it means the entire harvest chain executed: the validator accepted prf_mask with owns_q, the state plumbed the flag onto the codec, the engine registered the codec on the anchor clone, and the hook's harvest branch ran ahead of the confinement assert with path_tag=None. That last step is where the bug a unit test caught would have bitten: the harvest gate read is_grad_enabled() from inside a no_grad block, where it is False by construction, so the sketch would have stayed empty and this assert would have fired at step 20 instead of at test time. Timing was as predicted as well: one optimizer tick per step at batch 128 / mini 128, and an anchor cadence of 20 ticks puts the first fire at exactly step 20.

A methodological correction that belongs in the record

Three times in this session I extrapolated from a window far too short to carry the claim: a9 read as 1.7x slower than a8 from four step times (its per-step times in fact match a8's), R2 upload concurrency judged on four minutes of part counts, and R2 throughput projected at 2.2 MB/s where 20.6 minutes of data gives 5.78 MB/s, which is the difference between "the back-fill will not finish" and "it takes 6.7 hours". Each was corrected within the hour, and one error of the same class nearly justified killing a8, the cell that identified the gap mechanism.

24. a9 scored: anchor-owned Q is a trade-off, and Q governance turns out not to touch real drift at all

The mechanism works, verified by arithmetic rather than by absence of a crash. Five anchor fires at steps 20/40/60/80/100 with the refresh counter at 7/14/21/28/35, exactly 7 per fire. Under anchor ownership that counter can only move inside the anchor, so 35 after 100 steps proves the fast path never wrote Q; at cadence 1 it would read about 700.

Four predictions of five, and the failure is the informative one

P2 (gap level between a7 and a8), P3 (learning within 0.02 of a7), P4 (inflation falls rather than rises) and P5 (wire exactly 1232) all confirmed. P1 failed: I predicted the slope would be at or below a8's +0.001262 because anchor ownership is "the limit case" of a8's mechanism. It came in 7.3x higher. The middle outcome pre-committed in the a9 pre-read is the one that fired.

a9 is second on both gap measures, and the 0.0053 learning spread across all four arms is well inside the incumbent's own 0.0120 checkpoint spread, so that ordering carries no weight. Anchor ownership buys a better level than a8 and a flatter slope than a7, and is worse than each on the other axis. Neither FRLR arm dominates.

The finding: three arms, identical real drift, 55x different gated drift

A matched-step check stopped me publishing the opposite claim. a9's codec-free drift reads 0.005265 at step 120, a8's quoted figure was step 150 and a7's step 200, and drift grows with steps, so "a9 has the lowest drift in the program" would have been an artifact of comparing different points on the same curve.

a5b sits lower at steps 50 to 100 for the reason already established: token-IS suppressed its learning, and a model that learns less moves less.

What this forces

The run-3 selection rule was built on a false premise. It read "flattest gap slope among {a9, a10}", which presumed a9 would dominate a8. It does not, so as written it would send a 7.3x worse slope into the 20-hour run.

The obvious untested cell, one variable from a9: anchor-owned Q accumulating its sketch over several anchor fires before orthonormalising, instead of one minibatch per refresh. a9 beats a8 on gap level using a single minibatch of sketch data against a8's twenty steps' worth, which says slow-net alignment buys the level; a8's flatter slope says sample size buys the slope. Nothing in the matrix has both. Not scheduled, and it is new spend.

And the question the program keeps circling. Within the FRLR family the gap spans 5.08 to 6.83 and the slope +0.0013 to +0.0164, while capability and real drift are flat. Nothing measured in 200 steps distinguishes these arms on any quantity that matters to the deployment. That does not make the gap unimportant; it means its importance is unestablished at this horizon, which is exactly what the 600-step run exists to test.

25. a9's full trajectory reverses the a8 comparison, and no arm settles

a9 finished 200/200 with zero errors and ten anchor fires, refresh counter 70, exactly 7 per fire throughout. Its terminal validation is 0.6713426853707415, which is identical to a7's to the digit: both are 335 of 499 problems. A coincidence at the problem level, but it settles the capability question between them.

Why the registered criterion is NOT being rescored

The registered window is 100-120, a8 wins it, and switching to the window that ranks arms the way one now prefers is exactly the goalpost move this program has been disciplined about. Stated precisely: on the registered criterion a8 is the best arm, and that stands. What the late data shows is a reliability problem with using that number to predict 600-step behaviour, since a slope measured at a curve's turning point extrapolates badly by construction, and the 100-199 figure gives a8 +0.001485 only because its fall cancels its rise.

Correcting the constraint-cost claim made earlier today

Section 24 states that the operator's anchor-Q constraint "has a measurable cost" of 7.3x on the registered criterion. That was measured at a8's turning point and overstates the case.

On three of five measures a9 is at least tied best, and of the two where a8 leads, one is the turning-point artifact. So the honest revision is that the constraint's cost is not established and may be zero. Recorded as a correction rather than by editing the earlier claim away.

An operational finding that changes how a 600-step run should be configured

a9 was the first cell with the in-training R2 checkpoint sink enabled, and it turned teardown from a8's roughly two minutes into a bandwidth-bound wait. The log reports the upload as queued "async", and it is async with respect to training but not with respect to process exit: a9 sat at step 200 with the GPU at 0 percent while 19G uploaded, and exited within a minute of those uploads being killed. Measured progress was 16 of 74 parts in 7 minutes, so the full wait would have been about 55 minutes of idle GPU; stopping it cut the handoff to 11 minutes, and the checkpoint was never at risk because it sits on local disk with deletion disabled. For a 600-step run with three saves that is roughly 2.5 hours of idle GPU. Either make the sink genuinely asynchronous or leave it off and back-fill, which is what a5b through a8 did at no cost to occupancy.

26. a10: the codec's BIAS is what buys FRLR's entire gap advantage

a10 was a9's exact configuration plus frlr_unbiased=true, so the residual gain becomes the constant H/k and the reconstruction is exactly unbiased. One environment variable. It was killed at step 62 on two pre-registered triggers, per the instruction not to wait 200 steps when the signal is clear.

And the question the arm existed to answer

Removing the bias lowers real drift by 2 to 10 percent. Consistently in the predicted direction at all three probe points, so probably a real effect, and the same order as the 4 to 8 percent arm-to-arm noise already established across a7/a8/a9. Against a gap penalty of 2.56x, the trade is not close. The mechanism is the one the pre-registration named: the constant H/k gain is unbiased in expectation but has higher per-token variance, and the gap is a per-token KL, so it is exactly the quantity variance inflates.

a10 is also the only arm below the wire budget, at 1216 bits: 76 coordinates rather than 77, because the unbiased gain makes the per-token norm scalar unnecessary. Verified from the runtime mask_ratio of 0.9505208 = 1 - 76/1536 rather than from the config alone. It bought 16 bits and paid 9 nats.

What this settles, and what it does not

Run 3 is now running

The pre-registered selection rule was "flattest gap slope at 100-120 among {a9, a10}". a10 is disqualified, so a9 wins by the rule, and a9 satisfies the anchor-Q constraint. c600-a9-anchorq-val600 launched 23:45:53Z: a9's config at 600 steps, val at 300 and 600, probe cadence 5, and the R2 sink deliberately OFF because a9 showed the in-training sink idles the GPU at teardown, which for three saves would cost about 2.5 hours. Idle across the handoff was about 6 minutes. Kill triggers: the gap crossing the incumbent's 14.3, or val at 300 below 0.65.

What it decides. PRF exact-k is the only arm ever proven at 600 steps. Every FRLR result is a 200-step result, and no FRLR arm settles. a9 ran 5.92 at its registered window and 7.00 at step 199 with a late slope of +0.012172; continued linearly that reaches about 12 by step 600, still under the incumbent's 14.3, but if it accelerates as a7 did it crosses.

27. The bug the operator found: a spurious PPO ratio at every anchor fire

The operator sent two WandB plots showing actor/pg_clipfrac and actor/pg_clipfrac_lower spiking at exactly steps 20, 40 and 60, and asked why the clip fraction peaks when the anchor fires. It was a bug I introduced the same day, and it also falsifies a claim written into this program's notes repeatedly as fact: that pg_clipfrac is zero by construction because train_batch == ppo_mini makes the ratio identically 1.

The mechanism

The anchor fires at the top of train_batch, which is after that step's old_log_probs were recomputed in a separate call. My anchor_update_basis published the new basis immediately. So within one step the old-logprob forward reconstructed activations through Q_t and the train forward through Q_t+1. The PPO ratio exp(logp_new - logp_old) then departs from 1 because the measurement apparatus changed, not because the policy moved, and PPO dutifully clips it, truncating the gradient for 20 to 35 percent of tokens at 5 percent of steps.

The fix, which the codebase already documented

PowerSGD's anchor path solves this by staging: anchor_update_basis(staged=True) writes a candidate, and engine_workers.py publishes it only after every PPO minibatch sharing those old_log_probs has completed. Its comment states the reasoning verbatim. I had ported the harvest half of that contract and omitted the staging half. The fix adds _pending_frlr_basis, activate_staged_frlr_basis() and discard_staged_frlr_basis() (so a candidate from an update that did not commit cannot leak into a later policy pair), with four new tests including one that reproduces the bug: unstaged, the two forwards of one step differ; staged, they are byte-identical. 163 tests pass.

Scope: which results are affected

The rerun repairs the confound for free. Because it passes through step 200 on clean code, its own 100-120 window is a proper a9-equivalent, so the comparison that was provisional is settled by the same run that answers durability. Cost of the restart: 64 steps, about two hours.

28. Specification of the 600-step durability run

c600-a9-anchorq-val600, restarted 2026-07-27T02:05:56Z on commit f2ac3c6. Values below are the resolved config read from WandB, not the launcher's intent, because the engine truncates its log at start and launcher defaults do not always survive Hydra.

Duration, from measured rather than assumed rates

a9 is the identical arm and ran 199 logged steps: median 108.9 s/step, mean 115.3 s, p10 99.8 and p90 133.4, and its wall clock over 200 steps implies 115.0 s/step including overheads. So:

What it decides, and the kill triggers

PRF exact-k is the only arm ever proven at 600 steps; every FRLR result is a 200-step result, and section 25 established that no FRLR arm settles. Compare against the incumbent's validations at 150/300/450/600 of 0.6613 / 0.6633 / 0.6733 / 0.6613 and its gap of about 14.3.

a9 ran a gap of 5.92 at its registered window and 7.00 at step 199, with a late-window slope of +0.012172. Continued linearly that reaches about 12 by step 600, still under the incumbent's 14.3; if it accelerates as a7 did, it crosses. Kill triggers: the gap crossing 14.3, or validation at 300 below 0.65, which is under every incumbent checkpoint.

29. Re-scored on stability rather than reward: the ranking of all twelve arms

Full analysis, three figures and the corrections ledger: the stability ranking page. The short version is below.

Section 28's prediction, resolved

Section 28 registered the kill trigger as "the gap crossing 14.3" and reasoned that a9's late slope extrapolated to about 12 by step 600, "still under the incumbent's 14.3; if it accelerates as a7 did, it crosses". It accelerated and it crossed.

First step at which FRLR exceeds the incumbent: 417. First step after which it stays above for the rest of the run: 424. This is the rotation-invariant versus alignment-dependent split that section 20 derived before the run existed: PRF's codec error does not care where the activations point, so its gap is stationary; FRLR's tracks a subspace the policy keeps moving, so it is excellent while the basis is fresh and degrades as the policy walks away from it.

Two metrics that are not allowed to rank anything

actor/kl_loss is real drift multiplied by a codec-view inflation factor that itself moves 50x, and it spans 55x across a7, a8 and a9, three arms whose codec-free drift is identical to within 4 percent at matched step 120. actor/entropy is disqualified because the dense control sharpens the same way, so its decline is ordinary GRPO on maths, not compression damage. Neither appears in the ranking.

The ranking

Twelve program arms on gap stationarity, gradient behaviour and non-collapse. The incumbent and the dense control are references, not entrants. Twelve arms were run to beat the incumbent and none of them did.

Gap drift is the end level over the level at step 100; grad drift is the median of the last fifth over the median of the first fifth. A drift far below 1.0 (a8 0.05x, a9 0.40x, a2 0.49x) is a decaying startup transient, not a calm run, so it must be read next to the run maximum.

The two counterexamples that discipline the reading

What we would actually ship

PRF exact-k, 77 of 1536 coordinates with a constant 1/(1-p) rescale and a mask that is a pseudo-random function of seed, step and layer. It is unbiased, there is no side channel because the mask is derived rather than transmitted, there is no basis to broadcast and no anchor coupling to get wrong, and it is the only configuration in this program with 600 steps of evidence that the optimizer stays in a steady state: gradient block medians flat at 1.50 to 1.82 across all twelve blocks, a block maximum never above 4.645, a gap that moved 0.42 nats in 500 steps, and four validations inside 0.6613 to 0.6733. The two upgrades worth a horizon run, in order, are a4 (PRF exact-k plus CVC cross-entropy, same family, lowest risk) and a3 (sr_quant 2-bit byte-parity, a genuinely independent shot). FRLR is out for long-horizon work in every governance variant tested.

Stated at the width the evidence supports: on the short matched window 100-120 the incumbent is fourth, not first, behind a3, a5b and a6. Its win is a horizon win, and a3 and a4 are unproven rather than beaten. Codec-free drift cannot compare the two families at all, because the incumbent carries no probe. And compression costs about 1.4 to 1.6 points of validation against the dense control at 600 steps, a price both families pay equally.