Why does token ordering in LLMs create sequences rather than true temporal flow?
This explores why an LLM's left-to-right token generation produces a sequence — one token after another — without the lived, reflective duration we mean by 'time,' and what that gap costs.
This explores why an LLM's token-by-token generation produces a *sequence* rather than genuine *temporal flow* — and the distinction turns out to be more than philosophical hairsplitting. The cleanest statement of the gap is that token ordering is probabilistic selection without intervening reflection: each token is chosen from a distribution conditioned on what came before, but no 'thinking time' elapses between them that could change what comes next. Human discourse earns its meaning partly from duration — the pause that lets you revise, reconsider, abandon a sentence halfway. AI text only *appears* to unfold in time; it has order without the reflective interval that makes order meaningful Does AI text generation unfold through temporal reflection?.
The corpus shows this isn't just abstract — it has fingerprints in behavior. Models handle *causal* relationships far better than *temporal* ones, because causal connectives ('because,' 'therefore') appear explicitly and frequently in training text, while temporal order is usually implicit and must be inferred. The model learned the words for causation but never experienced sequence as elapsed time Why do LLMs handle causal reasoning better than temporal reasoning?. Relatedly, when LLMs rank items from a user's interaction history, they ignore the order by default — recency and sequence are invisible until a prompt explicitly points at them, at which point a latent sensitivity to order can be switched on Why do language models ignore temporal order in ranking?. Order, for these systems, is a feature you have to ask for, not a medium they live in.
The deeper point is that the same atemporality is why a sequence can't self-correct as it goes. Because generation moves forward without a reflective loop back, an early wrong guess gets locked in — across 200,000+ conversations, models drop ~39% in multi-turn settings by committing prematurely and never recovering Why do language models fail in gradually revealed conversations?. The same one-directional flow lets errors compound silently across long delegated workflows, corrupting roughly 25% of document content over many round-trips with no plateau Do frontier LLMs silently corrupt documents in long workflows?. True temporal flow would include revision; a sequence just accumulates.
What's striking is that several research directions attack the problem by *breaking* the linear-sequence assumption rather than accepting it. Diffusion LLMs use bidirectional attention so reasoning and answers refine *simultaneously* — answer confidence can converge while reasoning is still being reworked, which is much closer to revision-in-place than to a one-shot left-to-right stream Can reasoning and answers be generated separately in language models?. Meta's Large Concept Model abandons token-by-token generation for reasoning over whole sentence embeddings with paragraph-level planning, trading the flat sequence for a hierarchy that plans before it emits Can reasoning happen at the sentence level instead of tokens?. And LLM Programs wrap the model in explicit algorithms that manage state and control flow, effectively imposing structured time from the outside that the raw sequence lacks Can algorithms control LLM reasoning better than LLMs alone?.
The thing you might not have known you wanted to know: the 'sequence, not flow' limit isn't a bug to be patched — it's structural, the same root behind premature commitment, compounding errors, and temporal-reasoning weakness. The most promising fixes don't make the sequence smarter; they replace the linear sequence with something that can plan, refine, or loop — restoring, by architecture, the revisability that real temporal flow gives for free.
Sources 8 notes
Token ordering in LLMs follows probabilistic selection without intervening reflection or revision. Human discourse gains meaning from temporal structure—time spent thinking changes what comes next—but AI text production lacks this duration-in-reflection despite appearing sequentially composed.
ChatGPT excels at causal relations but struggles with temporal ordering because causal connectives are explicit and frequent in training data, while temporal order is often implicit and must be inferred contextually.
LLMs can extract preferences from interaction histories but disregard temporal order by default. Recency-focused prompts and in-context examples activate latent order-sensitivity, improving ranking without retraining.
Across 200,000+ conversations, all major LLMs show 39% average performance drop in multi-turn settings due to locking into incorrect early guesses. Agent mitigations recover only 15-20% of this loss.
Testing 19 models across 52 domains shows even advanced systems degrade documents by ~25% over extended relay tasks, with errors compounding silently without plateauing through 50 round-trips.
ICE shows that bidirectional attention in diffusion LLMs enables in-place prompting—embedding reasoning directly in masked positions refined alongside answers. Answer confidence converges early while reasoning continues refining, allowing early-exit mechanisms to cut compute by 50% while maintaining accuracy.
Meta's Large Concept Model operates on sentence embeddings rather than tokens, reasoning in a language-agnostic space before decoding to any target language. This hierarchical approach with paragraph-level planning produces more coherent output than flat token generation.
LLM Programs embed LLMs within explicit algorithms that manage control flow and state, presenting only step-specific context to each LLM call. This information hiding addresses capability and context window limits while treating complex reasoning as modular, debuggable sub-tasks.