The Decision That Wasn't

What the Free Transformer's latent actually learns, at 51M–124M parameters

Bryan Vine · July 2026 · github.com/bryanvine/free-transformer · Paper 2 of the series · Paper 1: Free Bits Aren't Free

TL;DR. Paper 1 priced the Free Transformer's latent honestly; this paper opens it up. We probe every surviving latent from our 51M–124M replication — per-bit information accounting, single-bit ablations, and a controlled steering experiment. Three findings. (1) The free-bits budget quantizes into a few soft channels: a κ=0.5 model concentrates its entire allowance in one of its 16 bits; a κ=1 model uses exactly three, at ~0.33 bits each. Ablating a live channel costs its full KL; the other 13–15 bits are dead weight. (2) Training history is written into the code's structure: the κ=1 run that trained cleanly learned a crisp 3-channel code, while its sibling that died and resurrected mid-training learned a diffuse 8-channel code carrying the same total information — the near-death left a structural scar, not just the 0.08-nat loss scar from Paper 1. (3) The "decision before speaking" is not observable at this scale. Live channels flip on sub-phrase timescales (expected runs of 1–5 tokens), correlate with no surface feature we tested (|r| ≤ 0.03), and pinning the latent during generation produces no measurable steering: samples sharing a fixed Z are no more alike than samples with fresh Z. At 51M–124M, the latent behaves as a per-token side-channel for next-token residual uncertainty — precisely the leak that Paper 1's honest accounting priced.

1 The question

The Free Transformer's motivating story (Fleuret, arXiv:2510.17558) is that a GPT should get to decide — commit to latent global properties of its output before emitting tokens. Paper 1 established what the mechanism costs at small scale and when its latent survives training. This paper asks the question that likelihood can't answer: the surviving latents carry up to a bit per token of learned information — information about what? Is it decisions, in any sense that persists across a sentence and steers a generation? Or something humbler?

We probe five live-latent checkpoints: the three most instructive at 124M — the pristine κ=1 run, its died-and-resurrected κ=1 sibling, and the resurrected κ=0.5 run — plus dev-scale (51M) checkpoints for replication of the pattern. Three instruments: per-bit information accounting (how much KL each of the 16 bits carries, and how persistent it is across positions), single-bit ablations (replace one bit with prior noise everywhere; measure the reconstruction damage), and a steering experiment (generate repeatedly from fixed prompts with the latent sequence pinned vs. resampled; if Z carries global decisions, generations sharing a Z should resemble one another more than generations with fresh Z — measured as word-3-gram overlap).

2 Finding 1: the budget quantizes into channels

Three panels of per-bit KL: the pristine kappa=1 run uses exactly 3 of 16 bits at about a third of a bit each; the resurrected kappa=1 run spreads the same total over 8 bits; the kappa=0.5 run uses a single bit. — **Figure 1.** KL carried by each of the 16 latent bits, per checkpoint. The budget (Σ) always saturates the free-bits allowance κ — but lands in 1, 3, or 8 channels depending on the run. Dead bits carry exactly zero.

Single-bit ablations confirm the accounting is causal, not cosmetic: randomizing a live channel costs reconstruction almost exactly the KL it carried (e.g., the pristine κ=1 run's three channels ablate to +0.369, +0.372, and +0.380 nats; every dead bit ablates to 0.000 ± 0.005). Notably the ablation costs sum to slightly more than the joint KL — the channels are mildly synergistic, not redundant. And the latent width lesson from Paper 1 sharpens: H=16 was never the capacity; at these budgets the model manufactures exactly as many ~⅓-to-½-bit soft channels as κ affords and abandons the rest.

3 Finding 2: the resurrection left a structural scar

Paper 1 showed the κ=1 seed-3 run dying at iteration 1,000, recovering by 3,000, and paying a ~0.08-nat scar in its final loss. The probes reveal what the scar is made of: where its pristine sibling learned three crisp channels, the resurrected run spread the same 1.00 bits/token across eight partial channels (0.37 + 0.20 + 0.14 + 0.11 + 0.07 + three <0.05). Same objective, same data, same budget, same final KL — different code architecture, determined by whether training passed through a collapse. The resurrected κ=0.5 run, by contrast, rebuilt the same one-channel code that never-collapsed κ=0.5 runs learn — suggesting the diffuse code is a mark of recovering under a larger budget, though with n=1 per condition this is a case study, not a law.

Methodological corollary: two checkpoints of this architecture with identical training curves-at-a-glance can carry structurally different latent codes. Any interpretability claim about "the" Free Transformer latent needs to say which training history it examined.

4 Finding 3: no decisions, no steering

Three independent measurements agree that, at this scale, the latent does not carry sentence-level decisions:

Probe	Result (all live channels, all checkpoints)
Temporal persistence	P(bit unchanged at next token) = 0.49–0.78 → expected run lengths of 1–5 tokens. A decision spanning a 20-token sentence needs >0.95.
Surface correlates	\|r\| ≤ 0.03 against position, word boundaries, punctuation, alphabetic class — the channels encode nothing we can name from the outside.
Steering (fixed vs. fresh Z)	3-gram overlap between generations sharing a pinned Z: 0.001–0.006; between different Z: 0.001–0.005. No consistent separation at any checkpoint, 124M or 51M.

The steering null is worth stating plainly, because it is the experiment a practitioner would most want to work: we pinned the entire latent sequence — the model's full "decision" bandwidth — and generated repeatedly at temperature 0.8. The samples sharing a decision were no more alike in topic, style, or wording than samples with decisions drawn fresh. Qualitatively too: fixed-Z continuations of the same prompt wander to unrelated topics exactly as freely as resampled ones.

What positive account fits all three results? The one Paper 1's economics already implied: the encoder, which reads the full sequence, spends its budget transmitting per-token residual uncertainty — a soft side-channel that tells the decoder something about the very next token that context alone can't determine. That is why the information flickers at token timescale, matches no surface feature (it encodes what's left over after the context), buys reconstruction almost exactly its KL, and steers nothing when pinned: from the prior, it's just well-shaped noise.

5 What this does and doesn't say about the original paper

FAIR's gains at 1.5B–8B are on prompted downstream tasks; ours is a 51M–124M likelihood-and- probes study. Both can be true: nothing here shows the latent can't become decision-like with scale — but our results make it a falsifiable question rather than a narrative. If the mechanism matures into decisions, three observables must move together as models grow: temporal persistence of live channels should rise toward sentence length, steering separation should become nonzero, and the recovery rate from Paper 1 should continue climbing. A 350M run measures all three; it's queued for the next weekend window on borrowed hardware. What this paper does establish: at the scales where most replications and ablations of new architectures actually happen, the Free Transformer's latent is a side-channel, and any small-scale study that assumes otherwise is measuring its own assumptions.

6 Reproducibility

One script produces every number and example in this paper from a checkpoint:

.venv/bin/python scripts/probe_latent.py \
    --ckpt runs/ft124m_free_k1_s1/best.pt --data-dir data/fineweb_edu \
    --out runs/probe_k1_s1.json

Probe outputs for all five checkpoints ship in the repo (paper/probe_*.json), alongside the code, configs, seeds, and the live research log. Compute for this entire paper: about two GPU-hours on an RTX 4080 SUPER.