§01 Setup
A used channel is not a causal channel
When a model reasons "step by step", it narrates in human language, a medium optimised for us, not for it. The hypothesis behind this line of work is that a model can instead reason through a compact, learned internal code: discrete symbols that are neither words nor raw activations, whose meaning emerges during training. Others have since taken that mechanism to real scale; this note is about the part we consider ours to keep: the test.
Because latent-reasoning systems share a seductive failure mode. You add an internal channel, watch the codebook light up, watch accuracy climb, and conclude the channel is doing the reasoning. Very often it is not. A model can emit tokens into a channel while routing the real computation around it: the channel is used, it correlates with good answers, and it carries nothing. Every interpretability claim made about such tokens is fiction.
Separating those two cases takes an architecture where bypass is impossible and a counterfactual protocol that corrupts the channel and watches what breaks. Below: the architecture, the protocol, the one run that passed it, and the sibling run the same protocol refused to certify.
- Line / run
- air_gap / V17
- Model
- 2 × 6-layer transformers, d=384 · 26.5M params
- Channel
- 64 slots · hard VQ, 1024×384-d
- Data
- TinyStories (vocab 3,000) + synthetic arithmetic
- Training
- 2-phase · 15 + 20 epochs · AdamW
- Interventions
- shuffle · random · zero
- Record
- eval_metrics.jsonl · 2026-01
- Status
- Concluded; replication package in preparation
Two transformers, one narrow bridge
A 6-layer encoder (the Reasoner) reads the question together with 64 learned query slots: positions whose only job is to accumulate a working state. A separate 6-layer decoder (the Speaker) must produce the answer. Both are trained from scratch: 26.5 million parameters in total, so nothing here is inherited from a pretrained prior.
The state is forced to become discrete
Each of the 64 continuous states is snapped to its nearest entry in a learned codebook of 1,024 vectors (384-d): a hard vector quantisation with straight-through gradients. At inference the channel literally is a sequence of 64 integers. That discreteness is what makes the interventions below well-defined, and what would make any downstream reading of the code auditable.
The air gap: no way around
The decoder never sees the question. No residual connection, no cross-attention to the input; its first and only context is the quantised code sequence. In the implementation this is one line: the decoder's input embedding starts with z_q and nothing else. If information reaches the answer, it went through the code.
Why build it this strictly
Weaker designs leak input to the decoder, and then "the channel is necessary" is confounded by the bypass. The air gap removes the escape hatch by construction, which turns necessity from an assumption into something you can measure. It is deliberately the strongest form of the experiment, and deliberately small, so the result is cheap to reproduce.
§03 Protocol
The causal-necessity standard
A result counts only if it clears a two-part bar. Competence: with the channel intact, the model solves the task above a meaningful baseline. Necessity: when the channel's content is corrupted, everything else held fixed, performance collapses back towards that baseline. Competence alone is the standard trap; it is satisfied by a model that uses its channel decoratively. Necessity is the discriminator.
We corrupt the channel three ways, and the severity ordering matters more than it looks:
Permute the order of the emitted codes. Preserves the code set and its marginal statistics; destroys sequence and binding. The most diagnostic test: a bag-of-markers channel survives it, a channel that binds meaning to position does not. Its blind spot, genuinely order-invariant content, is exactly what the next intervention covers.
Replace every code with a uniform draw from the codebook. Preserves length and type; destroys all input-conditioned content. Shuffle and random collapsing together is what licenses a claim about the content itself.
Remove the channel's content entirely. On an air-gapped decoder this collapsing is close to tautological (the decoder has no other input), so it is the weakest evidence of the three. A channel is only called load-bearing here when shuffle and random both break it; zero alone proves presence, not meaning.
The protocol runs at evaluation time, needs no retraining, and reports one number per task: the collapse delta between the intact and corrupted scores. The implementation is small enough to quote in full:
z_q, _, vq_info = self.vq(z, hard=True) # z_q: [B, 64, 384], the discrete IR
if ir_mode == 'random':
indices = torch.randint(0, self.num_codes, z_q.shape[:-1], device=z_q.device)
z_q = self.vq.embedding(indices) # length/type kept, content destroyed
elif ir_mode == 'shuffle':
idx = torch.randperm(z_q.shape[1])
z_q = z_q[:, idx, :] # code set kept, binding destroyed
elif ir_mode == 'zero':
z_q = torch.zeros_like(z_q) # presence removedThe evaluation loop scores intact and shuffled generations in the same pass: identical inputs, identical greedy decoding, identical everything except the lines above (train_phase2.py, evaluate).
ir_mode = intactshuffle (torch.randperm)
IR channel · 64 discrete codes (showing 8)SCOPE · the story task is reconstruction (input = target): there the channel carries the reconstruction, not reasoning. The reasoning-shaped evidence is the arithmetic task.
Intact: the model clears the competence bar
One air-gapped model, two task heads, 20 epochs of phase-2 training. With the channel intact it scores 1.00 on the synthetic arithmetic task and 0.633 token-F1 on the TinyStories task. Decoding is greedy, so these intact figures are deterministic.
Shuffled: the same model falls apart
Permute the 64 codes, with the same inputs and the same decoder, and arithmetic drops from 1.00 to 0.06, story F1 from 0.633 to 0.109. The channel's ordering carries the computation; scrambled thoughts produce broken answers. That is the collapse a causal channel must show, and the negative controls in note 2 show how rarely it does.
Single run; the shuffle permutation is unseeded, so treat the corrupted floors as ±a few points across re-runs. Last-epoch figures quoted.
Read the two tasks differently
We scope this claim carefully. The story task is reconstruction (input equals target), so on real English the channel demonstrably carries the reconstruction, not reasoning. The reasoning-shaped evidence is the arithmetic task, where the answer is not present in the code by construction and still collapses under shuffle.
Stability check: best story F1 0.637 at epoch 13, essentially flat through epoch 20, a plateau rather than an overfit spike. Three <UNK> tokens in the epoch-20 samples, so the eval reads real generations.
What has actually been proven
On this 26.5M-parameter model, the discrete channel is the sole causal path from question to answer, measured under intervention, not inferred from a lit-up codebook. It is an existence proof of a mechanism, and nothing more: no comparison to chain-of-thought is made or implied, and note 2 records what happened when we tried to scale it.
§05 The control
The same test refuses to certify a weaker sibling
A protocol that always says yes is worthless, so here is the case where it said no. V17_ter is the same architecture with one change: the story head predicts the next segment instead of reconstructing the input. Same interventions, same eval:
| IR mode | Arithmetic acc | Story F1 |
|---|---|---|
| intact | 1.00 | 0.633 |
| shuffle | 0.06 | 0.109 |
| Collapse: −94% / −83% → channel certified load-bearing. | ||
| IR mode | Arithmetic acc | Story-pred F1 |
|---|---|---|
| intact | 1.00 | 0.262 |
| shuffle | 0.228 | 0.187 |
| zero | 0.00 | 0.182 |
| Story margin over shuffle: +0.074, declining over training → not certified. | ||
The arithmetic channel passes in both runs. The story channel does not: 0.262 intact against a 0.187 shuffle floor is a +0.074 margin that declines over training (best 0.275 at epoch 1). The diagnostics say why: teacher-forced loss on the predictive head sits at ~6.07 per token (the head is under-fit), and the input/target token overlap of the dataset is ~0.21, right at the shuffle floor. The metric is being carried by generic overlap, not by the channel.
This is the methodological point of the whole note: the standard discriminates. It certified V17's channel and refused V17_ter's on the same data, same architecture and same interventions, which is what makes the one positive result worth believing.
§06 Limits
What this result does not say
- No chain-of-thought comparison. There is no CoT baseline anywhere in this run. Nothing here supports a parity or superiority claim over natural-language reasoning, and we make none.
- Mechanism proof, not a system. 26.5M parameters, trained from scratch, on TinyStories and templated arithmetic. Small scale is deliberate (it removes the pretrained-prior confound and keeps the result reproducible), but it is also the result's boundary.
- It did not survive scale-up. Every attempt to scale the mechanism or retrofit it onto a pretrained backbone failed: a ~190M scale-up collapsed in training, and two retrofits produced channels that were used but not causal. Those records are the companion note.
- Single seed, unseeded shuffle. One training run per configuration; the shuffle floor carries run-to-run noise of a few points. Intact figures are deterministic under greedy decoding.
- The real-English result is reconstruction. Stated three times on this page because it is the easiest thing to over-read.
The failures are documented with the same care as the success: Note 2 · three ways a reasoning channel fails silently →
§07 Context
Where this sits in the literature
The direction is active and better-funded teams have taken the mechanism much further than we did; their work is the reference point, and this note is complementary to it. What the field mostly does not report is a content-corruption necessity test, which is precisely the part we keep.
arXiv 2502.03275 · Meta · 2025
Mixes VQ-VAE discrete latent tokens with text at scale and reports gains: the discrete-latent mechanism, shipped. No content-corruption necessity test on those tokens is reported.
arXiv 2604.22709 · IBM · 2026
Abstract-CoT · "Thinking Without Words"
Replaces verbal chain-of-thought with a reserved abstract vocabulary on pretrained models, up to 11.6× fewer reasoning tokens: the closest shipped analogue to an IR channel. Makes no per-token causal-necessity claim; this protocol is the test such tokens would need.
arXiv 2512.21711 · 2025
Finds that popular latent-reasoning tokens often act as uninterpretable placeholders exploiting dataset artefacts: independently, the exact failure mode this protocol is built to catch, and did catch in our own negatives.
arXiv 2512.19171 · 2025
A continuous latent reasoner with a separate talker/decoder: the continuous counterpart of the decoupling idea, where the field's momentum currently is.
arXiv 2606.29712 · 2026
Why Struggle with Continuous Latents?
Argues discrete latents beat continuous ones on interpretability: the bounded, enumerable-channel property this architecture takes to its extreme.
arXiv 2603.22582 · 2605.24286 · 2604.10693
The CoT-faithfulness cluster
Formalises causal, mediated-path evaluation for natural-language reasoning traces. The necessity standard here is the discrete-channel counterpart of the same discipline.
§08 Conclusion
The test outlives the architecture
Whether machine-native reasoning ultimately matches mature chain-of-thought is an open question this work does not settle. The architecture that carried the proof has already been superseded; the protocol has not. Corrupt the channel, hold everything else fixed, and believe only the channels that break: that test applies to any discrete latent system, including the ones that superseded ours. The notes in this series apply it to our own runs, negatives included.
And one direction we would test next, stated as a direction and not a result: keep the reasoning itself continuous (where the field's momentum is), but make the interface between reasoning segments discrete, air-gapped and auditable, so the same counterfactual test still applies. The segment length becomes a dial between a full air-gap and fully continuous thought.
◆ Provenance · what each claim rests on
All arXiv identifiers and the IBM token-reduction figure were verified against the source papers in July 2026. This is a concluded research line, published for its method value.