Seven percent of the FLOPs, and no error to show for the rest

Start with the observation from the founding note: a transformer runs the same dense arithmetic on every token, whether the token was obvious or hard. That is the first of the three wastes we set out to fix. This note is the first measurement of the fix.

The mechanism is small. Mind-1B carries a cheap running prediction of its own next input. Each step, it subtracts the prediction from what actually arrived. The residual is the surprise, and it costs exactly one subtraction to compute. We then use that number as a throttle on the expensive work: a channel whose input matched the prediction is left alone, its previous state reused, while a channel that got surprised is recomputed in full.

To see whether that idea survives contact with a real signal, we built a toy stream with a lot of structure in it, the kind of redundancy that fills most real text, and let the gate decide, per token, how much of the network to actually run.

The important half of that result is the second clause. Skipping computation is easy if you are willing to be wrong; the whole point is that the gated model produced the same output as the fully dense one. On this stream, the skipped work genuinely did not change the answer. Compute followed surprise, and surprise was scarce, so compute was scarce.

Why this is not just early-exit

Adaptive-compute schemes usually decide, per token, how many layers to run before exiting. That helps, but it is a coarse knob: the whole model still steps forward together. Surprise gating is finer. It works per channel, and the signal driving it is a quantity the model was already computing anyway. Prediction error is not a bolted-on controller; it is the residual you get for free the moment you keep a running guess.

That matters because the same signal is doing more than one job. The surprise that throttles compute is also the currency that gates memory, and it is the trigger that ignites the shared workspace when it crosses a threshold. One number, computed once, wired to the throttle, the memory, and the broadcast. A single economy rather than three controllers arguing.

What the gate does not buy

Two honest caveats, because that is the house rule.

• This is an inference saving, not a training saving. Training still runs dense bf16 matmuls for the gradient, and the plan says so out loud. The throttle earns its keep at deployment, on the stream, not on the cluster.
• 7% is the number for a deliberately redundant stream. A harder, higher-entropy input surprises the model more often, opens the gate more often, and costs more. That is the design working as intended: the model spends where the information is. The claim is not always 7%; the claim is that compute tracks difficulty instead of ignoring it.

There is a companion measurement from the routing prototype that points the same way. With no learned router at all, regions self-assemble into a coalition by phase-lock, and about 24% of them are active on an average token, with the coalition growing as the token gets harder. Zero router parameters, and the active fraction still moves with difficulty. Two different mechanisms, one behavior: the model gets smaller when the work gets easier.

Compute that scales with difficulty was one of the three properties we wanted the transformer to give us for free. It does not. This is the first evidence we can build it in.

None of this is the 1B model yet. It is a numpy prototype whose only job was to prove the mechanism is real and worth carrying up the ladder. It cleared that bar. The next gate is to reproduce it inside a 100M PyTorch core that stays within a couple of perplexity points of a dense baseline while most of its regions sit idle. That run happens on the two-B300 box, and when it passes or fails, it gets its own note.