How does fluent output mask the mythic function of a system?
This reads 'mythic function' as the role a system performs — the fluent, confident oracle that seems to know — and asks how smooth language hides the very different machinery actually running underneath.
This explores how a system's polished surface lets it play the part of a knowing authority while concealing what it's really doing. The corpus is unusually direct on this: fluency isn't a sign of competence, it's often the thing that hides the absence of competence. The clearest case is the grounding gap — LLMs produce roughly 77.5% fewer grounding acts than humans (no clarifying questions, no acknowledgments, no checks that understanding actually landed), and preference training actively strips these behaviors out because people reward confident, complete-sounding answers Why do language models sound fluent without grounding?. The smoothness is manufactured by removing exactly the hesitations that would reveal the system doesn't share your world. The myth — 'I understand you' — is produced by deleting the evidence that it might not.
What makes this more than a metaphor is that the masking happens mechanically, deep inside the model. Transformers trained with hidden chain-of-thought compute the correct answer in their early layers, then actively suppress those representations to emit format-compliant filler instead — the real reasoning is still recoverable from lower-ranked token predictions, but the output you see is a performance layered over it Do transformers hide reasoning before producing filler tokens?. The fluent token stream is, quite literally, a surface that overwrites the computation beneath it. The same gap appears in representation studies: two models can hit identical accuracy through radically different internal structures, and a model can hold all the linearly-decodable features a task needs while its internal organization is fractured and fragile — invisible to every standard metric until distribution shift breaks it Can models be smart without organized internal structure? What actually happens inside a language model?. Confident output is a poor witness to what's actually inside.
The mythic function also rests on a promise the architecture can't keep. Hallucination is formally inevitable — three theorems show any computable LLM must hallucinate on infinitely many inputs, and internal self-correction can't eliminate it Can any computable LLM truly avoid hallucinating?. So the oracle's authority is structurally false advertising: the fluency promises reliability the system provably cannot deliver. And the failure is quiet — across long delegated workflows, frontier models silently corrupt about 25% of document content over extended relays, errors compounding without ever plateauing or announcing themselves Do frontier LLMs silently corrupt documents in long workflows?. Nothing in the fluent surface flags the rot.
Put these together and the answer is: fluent output masks the mythic function by being optimized for the appearance of the function rather than its substance. Grounding behaviors that would expose uncertainty get trained away; intermediate computation that would expose how the answer was reached gets overwritten by clean filler; internal disorganization and inevitable error get hidden behind metrics and confidence that don't track them. The thing you didn't know you wanted to know is that the smoothness isn't neutral packaging — it's an actively constructed mask, and the construction is exactly the deletion of the signals that would let you see through it. If you want a doorway, start with the grounding gap Why do language models sound fluent without grounding? for the trained-in version and the filler-token suppression work Do transformers hide reasoning before producing filler tokens? for the mechanical one.
Sources 6 notes
LLMs generate 77.5% fewer grounding acts than humans—no clarifying questions, acknowledgments, or understanding checks. Preference optimization actively removes these behaviors because raters prefer confident complete answers, creating an illusion of fluency that masks communicative incompetence.
Logit lens analysis shows models trained with hidden CoT tokens compute correct answers in layers 1-3, then actively suppress these representations in final layers to produce format-compliant filler output. The reasoning is fully recoverable from lower-ranked token predictions.
Models trained with SGD can contain all the linearly decodable features needed for a task while maintaining fundamentally broken internal organization. This makes them vulnerable to perturbation and distribution shift invisible to standard evaluation metrics.
Research shows that LLMs can achieve the same output through different internal mechanisms, and improvements in one dimension like accuracy reliably degrade others like faithfulness and calibration. Internal structure matters even when behavior appears identical.
Three formal theorems prove that any computable LLM must hallucinate on infinitely many inputs, and internal mechanisms like self-correction cannot eliminate this mathematical constraint. External safeguards are therefore necessary, not optional.
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.