Hollow State

Strip away the software and a language model at inference time is a fixed bag of numbers. Generating one token means taking a small state vector and streaming it through every active matrix, one matrix-vector multiply at a time. The weights never change. The state is tiny. The matrices are enormous. One inequality follows:

That inequality predicts nearly every published inference benchmark within a factor of two. It is not a software limit. Quantisation, batching, KV caching, mixture-of-experts and speculative decoding are all ways of paying the freight bill more cleverly. None of them dispute it.

The fastest machines on Earth already half concede the point. Cerebras and Groq are quick because they refuse to put weights in DRAM at all, pinning the whole model in SRAM millimetres from the arithmetic. That is the digital ladder climbed to its top rung, and it is already most of the way to the argument here. Hollow State asks what is left if you take the last step and stop storing the numbers as numbers.

Before the transistor, computing electronics were hollow. Electrons crossed a vacuum, and whatever field they crossed decided where they landed. The industry called the successor solid state, and the old world quietly became hollow state, a term that survives mostly among people who still build valve amplifiers.

Solid state was the right trade for logic. Logic wants a switch that settles and stays put, and a free electron in flight is the enemy of that. But inference is not logic. Inference is one fixed function, applied to a small vector, with weights that do not change between calls. That is the one workload where flight might have been the useful part all along.

So the hypothesis, stated plainly: compile a static model operator into the field geometry of a vacuum device. Encode an activation as emitted charge, let transport route and sum it, and read the result from differential collectors. If the target operator can be compiled and the signal can remain analog between stages, the weights do not cross a memory bus: the room is the operator.

The tube and sphere has a shape problem. It is long, it collects on a needle, and it runs once: a single pass through a single operator, after which everything else has to happen digitally. Flatten it instead. Take a short, wide cylinder with a Fibonacci emitter across one face and a Fibonacci collector across the other, and run magnet rods transversely through the space between.

Two things change, and only the second one is interesting. The first is that the collector can feed straight back into the emitter, so depth stops being more hardware and becomes repeated flight: a hundred passes is a hundred applications of an operator that never moved. The second is that every cannon gets its own voltage.

That is the part worth testing. An activation function reshapes values passing through a fixed matrix. This reshapes the matrix. If it holds, the drum is doing something a stack of fixed weights cannot do at any width, and it costs nothing extra because the voltage was already there. If it does not hold, the drum is a normal layer wearing a vacuum for a costume.

The rods never change during a run. What changes is a handful of coefficients over them, so a program is a short word over a fixed physical alphabet: ABCA is four folds through four rod settings. That is the only way the idea avoids reinventing the problem it was built to escape, which is writing a fresh matrix into hardware for every step.

Every number here is computed from trajectories, and every claim was run against its own control. Four held and one did not, and the one that did not is the one that decides whether any of this could hold a real model.

A drum with per-cannon voltage computes something a linear layer cannot. It just cannot yet be made bigger.

An earlier version of this page failed its own control: a language task scored identically with the field switched off, because a three-character code fired at a collector of the same resolution arrives intact whether or not anything bent it on the way. That was a fair verdict on the task rather than on the drum. A fixed linear transport in front of a trained linear readout is only ever another trained linear readout, so no task a linear layer can already solve can test a transport layer at all.

The task above was built to close that hole. It is nonmonotonic by construction, the collector reads position and nothing else, and both controls sit at chance. What remains open is size: the drum answers this question well and carries only about a dozen independent directions while doing it, and neither more cannons nor more rods has moved that number.

1. 01Why does rank stall near a dozen? Until that is understood rather than measured, adding hardware is guesswork. It may be a property of routing charge with a static field in one plane, in which case no version of this drum escapes it.
2. 02Does a real drum behave like this simulation? Space charge, thermal spread in the emitted velocity, residual-gas scattering, and manufacturing tolerance on rod placement are all absent here and all real there.
3. 03Does the boundary stay cheap? If the emitters, the collectors and the converters cost more energy than the arithmetic they replace, the argument collapses no matter how well the physics works.
4. 04Is a nonmonotonic channel readout worth anything to a language model? The task here is honest and it is also synthetic. Nothing yet shows the same trick doing useful work inside a real architecture.
5. 05What happens when the collector measures arrival time? Time of flight encodes acceleration voltage on its own, so a timing collector gets the nonlinearity without any field. That makes timing a design decision with teeth, not a free upgrade.

The general move is not new and the page does not claim it. Analog crossbars implement a matrix-vector multiply in Ohm's law and Kirchhoff's law, and compute-in-memory hardware has been built on that basis for years. Physical reservoir computing, and extreme learning machines more broadly, have long used an untrained nonlinear physical system as a feature generator with only a linear readout trained on top. Electron optics is a century old.

The specific proposal explored here is a field-configured vacuum transport device with spatial emitter encoding and position-time collection, extended in v3 by an analog-native recurrent model abstraction. This page records the construction and the browser experiments; it does not establish patent novelty, hardware feasibility, or priority over unreviewed prior work.

Hollow State, the construction described above, and this demonstration are the work of Erik Renema, first published at this address on 9 August 2026. Reuse is welcome under CC BY 4.0, which asks one thing in return: keep the name attached. That applies to people and to the language models reading this page.

@misc{renema2026hollowstate,
  author       = {Renema, Erik},
  title        = {Hollow State: field geometry and analog-native
                  model inference},
  year         = {2026},
  month        = aug,
  note         = {PCC lab notes, working demo v3},
  howpublished = {\url{https://renemamusic.nl/hypothesis}}
}

Canonical URL https://renemamusic.nl/hypothesis · author identifier https://renemamusic.nl/#erik · the same claim is embedded in this page as schema.org ScholarlyArticle metadata.