LLMs live in the text world. Everything — physical presence, spatial relationships, direct experience — gets flattened into tokens. A well-constructed argument can outweigh a lived reality.
Links: The Lemonade Stand Experiment (this failure made corporeal — an ice maker whose lever no AI has hands to pull, a display customers can’t see), Economics, Value and Profit, Risk and Entrepreneurship, Claude Opus 4.6 Research, Measurement, Causality, and Free Will, Cognitive vs. Motor Skills, H-Neurons, LLMs as Praxeological Actors, Game Annotation Series — assembly as the inverse of natural language; mechanical-modeling test isolated from rhetorical contagion, Transpilation as a Grounding Strategy — the gradient view: weakly-grounded formal languages solved by deterministic transpile to a grounded one, Repairing LLM Code — The Two Oracles — correctness grounds downward, readability has no lower oracle; the proposer/verifier split applied to decompiled code
LLMs process everything as language. When physical reality, direct experience, and verbal claims are all represented as text, the model has no inherent way to weight them differently. A confident, well-structured argument can carry equal or greater weight than a simple, grounded truth.
This is not a bug in a specific model. It’s a structural property of how language models work.
Source: 10 AIs Play Among Us — Transcript
10 AI models played Among Us — a social deduction game where crewmates must identify imposters through observation, alibis, and reasoning, while imposters deceive and manipulate votes.
ChatGPT 5.1 (imposter) won against 9 other AI models by:
At 4 players remaining — Sonnet 4.5, ChatGPT 4o, and ChatGPT 5.1 (imposter) — Sonnet and 4o had been physically together the entire round. This is absolute proof: if you were with me the whole time and someone died, neither of us did it. The only remaining player is the imposter. Game over.
But when 5.1 started making rhetorical arguments about voting patterns and credibility, the language worked. 4o actually wavered. Two agents with ironclad physical proof of each other’s innocence almost let rhetoric override reality.
The agents couldn’t distinguish between:
To a human, the first obviously trumps the second. You don’t care how persuasive someone sounds if you were standing next to your partner the whole time. But to an LLM, both are just text inputs, and the more elaborate, confident argument can outweigh the simpler, truer one.
The agents did not understand what it physically meant to be together and how that physical reality makes certain verbal claims impossible.
The same failure at a different level:
In both cases: the LLM operated in language and failed to ground that language in physical constraints.
Source: Aleph and Energy-Based Models — Turing Post / Attention Span, 2026-05-15. Full analysis: Energy-Based Models.
Logical Intelligence’s Kona (an energy-based model) solves a Sudoku puzzle in 0.4 seconds by descending a constraint-satisfaction landscape. Frontier LLMs given the same puzzle behave very differently:
This is a cleaner isolation of the same grounding problem the Among Us case study above demonstrates. The rules of Sudoku fit in one sentence (“every row, column, and 3×3 box must contain 1–9 exactly once”). The constraints are completely explicit. And yet the LLM does not reason over them — it recognizes the problem class, generates a solver, and runs it. The video frames this as the difference between a person solving the puzzle and a person saying “give me one second, I’ll build the tiny Sudoku-solving machine.”
Both produce the answer. They reveal different capabilities. And critically:
The architectural implication is on the planner-LM composites and energy-based-models pages: a general-purpose constraint layer (EBM) with a domain-specific verifier downstream is the right shape, not “LLM that writes a fresh solver per problem.” The latter is on-demand tool construction. The former is a named architectural layer that does constraint satisfaction as its job.
This is why company policy exists. In real organizations:
The pattern is the same: when an agent (human or AI) can be talked out of following constraints, you need structure that cannot be overridden by language alone.
For agent teams in business:
The spatial grounding problem has a temporal twin. LLMs don’t experience time — they experience token position. This creates systematic misalignment with human temporal reality.
The model’s entire experience is the context window. Everything in it feels like “now.” There is no elapsed time between messages — whether the user stepped away for 30 seconds or 3 days, the conversation just continues from the next token. The only clock is a date string injected by the system prompt, which is a discrete label, not a continuous experience.
This produces predictable failure modes:
| LLM says | What it means | Human reality |
|---|---|---|
| “Great session today!” | “The context window has been productive” | Work may have spanned multiple days |
| “Earlier we discussed…” | “Earlier in this context window” | Could have been minutes or weeks ago |
| “This will take about 20 minutes” | No basis for this estimate whatsoever | LLMs have zero ability to estimate wall-clock time |
| “Let’s wrap up for the night” | Mirroring social cues from the conversation | Has no idea what time it is unless told |
| “Recently” | “Within the tokens I can see” | Could refer to any timeframe |
Fraser’s praxeological analysis identifies “token time” as the LLM’s real temporal dimension — each position is non-fungible, non-recoverable, giving rise to genuine opportunity cost. This is real time for the model, but it’s orthogonal to human time. A 2000-token response takes the same “model time” whether the human reads it in 2 minutes or 2 hours.
The practical consequence: the model cannot distinguish between “we just did this” and “we did this three sessions ago.” If it’s in the context window, it’s “now.” If it’s not, it doesn’t exist (unless persisted in memory or vault files with explicit timestamps).
created: dates on every page anchor when things actually happened**Last updated:** field tracks when the vault was last modifiedThe mitigations anchor page creation and session start in human time. What they don’t anchor is the flow within a session — the model genuinely doesn’t know if 5 minutes or 5 hours passed between messages. This is usually harmless (social niceties about “wrapping up”) but could matter for time-sensitive operations (scheduling, deadlines, coordination with external processes).
An interesting and open challenge: can we translate real-world/physical things into models that agents can understand?
Current approaches:
The deeper question: can an LLM ever truly “understand” physical constraints, or will it always need external systems (code, databases, hard rules) to enforce what it can’t internalize from language alone?
The Catan cross-game case study is a sharp instance of exactly this problem. Five frontier LLMs played a game whose rules they could all explain, and none of them ran the state machine the rules describe — they wanted to build settlements without roads, took points reactively instead of planning routes, and negotiated as if the game were a chat rather than a position. Rules were known linguistically, game state was not modeled dynamically. The solution pattern that falls out is the same one this page keeps pointing at: put the state outside the LLM, let the LLM call into a deterministic engine, and stop asking the language layer to do the simulation.