What does an LLM gain and lose by reasoning in words rather than latent state?

## Two channels for the same computation A model's reasoning has to happen somewhere. In chain-of-thought it happens in the output channel: each step is decoded into a token, appended to the context, and read back by the next step. The alternative is to keep the reasoning inside the network - to let the model iterate on its own continuous representations without ever turning them into words. Both are ways of buying serial computation. They differ in what survives each step. ## The bottleneck argument for latent reasoning A hidden state is a vector with thousands of dimensions, carrying a graded, ambiguity-preserving representation of where the model is in the problem. Decoding turns that into one token from a vocabulary of perhaps a hundred thousand entries - a handful of bits. Most of the state is discarded, and what remains is forced into a single committed choice. That commitment is not neutral. It collapses a distribution over possible continuations into one branch, and everything after it is conditioned on that branch. Research on continuous or latent reasoning - feeding the model's own hidden representations back as the next input instead of decoding them, sometimes described as reasoning in a continuous thought space - is motivated by exactly this: keep the model's uncertainty alive across steps, and avoid paying for words when the words are not the point. Related work on filler or pause tokens tests the weaker version of the idea: can extra compute alone help, with no meaningful content emitted? Results there are real but modest and task-dependent, which itself tells you something - a good chunk of chain-of-thought's benefit comes from the content of the steps, not just from the passes they buy. ## What the words buy The case for verbalization is not that words are the best representation for computation. It is that a computation you can read is a computation you can operate. **Inspection.** A wrong answer in a dosing calculation is a mystery; a wrong answer with a visible conversion step is a bug you can point at. Intermediate values are only checkable if they exist as values. **Verification.** Because steps are discrete text, external verifiers can score them - a unit checker, a calculator, a schema validator, a judge model, a test suite. Process-level supervision of any kind needs a process you can see. **Intervention.** A token trace can be truncated, edited, branched from, or retried at a specific step. You can re-run just the tail. Latent state offers no comparable handle. **Reuse.** Tokens are cacheable and portable. A trace can be logged, replayed, attached to an incident report, shown to an auditor, or turned into training data for a smaller model. A continuous internal state is none of those things. **Monitoring.** There is a governance argument, made prominently by safety researchers across several labs, that reasoning conducted in natural language gives a rare window into a model's process - and that architectures which move reasoning out of tokens would close it. Whether or not you weight that heavily, it is a live consideration in how frontier systems are being built, and worth naming in a senior interview. ## The honest caveats Two, and a strong candidate volunteers both. First, readability is not faithfulness. A trace can be well formed, plausible and not the actual cause of the model's answer. Verbalization gives you an artifact to monitor; it does not guarantee the artifact reflects the computation. Treat the trace as evidence, not testimony. Second, the bottleneck may be doing useful work. Forcing each step through a discrete symbol imposes a kind of discipline: it commits the model to a definite intermediate claim that later steps must live with, and it keeps steps in the distribution the model was trained on. Unconstrained continuous iteration has fewer guardrails, and part of why latent approaches have not displaced token reasoning is that they are harder to train stably and harder to evaluate. ## Where this stands in 2026 Production systems reason in tokens. The practical variation is in where those tokens are shown, how many of them are spent, and what verification runs over them - not in whether reasoning is verbalized at all. Latent and continuous-thought approaches remain an active research direction with promising results on specific tasks, notably ones with heavy search or backtracking, and no broad displacement of chain-of-thought. ## Answering it well Name the bottleneck honestly - words are a narrow channel and the model has more state than it can emit. Then argue that the operational value of a legible trace (verification, intervention, logging, monitoring) currently outweighs the lost bandwidth, and that the field is exploring the alternative rather than having settled it. Close with the caveat that a legible trace is not a guaranteed faithful one, so you would still verify outcomes, not just read prose.