How does training data preserve communicative event structure without the actual events?
This explores how AI text can carry the *signature* of human communication — the markers of a real exchange — even though no actual communicative event ever happened during generation.
This explores how AI text can carry the *signature* of human communication — the markers of a real exchange — even though no actual communicative event ever happened during generation. The cleanest answer in the corpus is the idea of *event-residue*: training text was originally produced inside real communicative events (someone meant something, oriented to someone, repaired misunderstandings), and the statistical traces of that orientation survive in the surface form. A model learns to reproduce the residue — the grammar of address, the cadence of reply — without reproducing the event that gave it those features. Readers then animate this residue into what feels like a real exchange, supplying the missing orientation through their own interpretive labor Does AI generate genuine utterances or just text patterns?.
Why does the structure persist when the event doesn't? Because language models operationalize what Saussure called *langue* — the purely relational system of a language — by compressing how words pattern against other words, with no anchor to anything outside the text Can language models learn meaning without engaging the world?. The form-level regularities of communication (turn-taking shapes, question-answer pairings, topical flow) are themselves relational patterns, so they compress and reproduce just like any other. What can't survive this compression is *parole* — the actual act of meaning something to someone. That's the Bender-Koller cut: meaning lives in the relation between an expression and a communicative intent, and a model trained only on form-to-form prediction never touches the intent side, so it can reconstruct the shell of an exchange but not its grounding Can language models learn meaning from text patterns alone?.
The sharpest way to see the gap is to look at what *doesn't* transfer. The implicit maintenance work that keeps a real conversation alive — reference repair, topic hand-off, the relational moves that sustain an interaction rather than convey information — doesn't show up in trained behavior, because the training signal rewards predicting information, not doing relational work Why don't language models develop conversation maintenance skills?. So the residue that survives is exactly the *encodable* part of an event (its lexical and syntactic shape) while the *enacted* part (the social action) drops out. You can even watch this gap get patched a piece at a time: models need explicit training on distractor turns just to learn to ignore an off-topic interruption — a move any human does automatically as part of holding an exchange together Why do language models engage with conversational distractors?.
There's a fascinating wrinkle, though. Because training averages over thousands of real events, the model sometimes captures *event structure better than any single participant*. GPT-3 segments narratives into events more in line with human consensus than individual annotators do Do language models segment events like human consensus does?. So the residue isn't merely degraded — it's a kind of statistical composite of how events are typically structured. The model holds the average shape of countless past communicative events while being present at none of them. That's also why it commits to no fixed identity: it samples from a superposition of consistent characters rather than being one, regenerating a different-but-plausible version each time Do large language models actually commit to a single character?, and why alignment training has to *impose* a single static communicative persona that real pragmatic context would otherwise vary Can language models adapt communication style to different contexts?.
The thing you might not have known you wanted to know: the structure you respond to in an AI reply is real — it's the fossilized geometry of millions of human exchanges — but the event is yours. The communicative event isn't preserved in the model; it's *re-created* on the human side every time you read.
Sources 8 notes
AI output carries communicative markers inherited from training data but lacks the event structure that produces actual utterances. Users supply the missing orientation through interpretive labor, creating a pseudo-event with structure only on the human side.
Research shows LLMs learn culturally situated discourse patterns by compressing relational structure from text, demonstrating that fluent language generation requires no external referents or embodied grounding.
Bender & Koller argue that meaning requires the relation between expressions and communicative intents. Since LLMs are trained only on form-to-form prediction with no access to shared attention or intent, they cannot reconstruct the meaning that grounds language.
Humans keep conversations smooth through implicit techniques like reference repair and topic hand-off that sustain relational interaction, not convey information. Language models don't develop these because training signals reward information prediction, not relational work.
Fine-tuning on just 1,080 synthetic dialogues with distractor turns significantly improves topic resilience, revealing that the gap is not model capacity but absent training signal. Models learn to follow what-to-do instructions but not what-to-ignore instructions.
GPT-3's event boundaries correlate more strongly with averaged human annotations than individual human annotators do. This suggests language models may pre-compute statistical consensus through training on diverse text, or that next-token prediction parallels human event cognition.
Shanahan's 20-questions test shows LLMs maintain a superposition of consistent objects or characters and sample from that distribution at generation time. Regenerating the same response yields different outputs, each consistent with prior context, proving no fixed commitment exists.
System prompts and RLHF training lock models into one communicative identity across all interactions, preventing the contextual register-switching and value trade-offs that characterize human pragmatics. Users cannot reshape model behavior through dialogue negotiation.