What happens to anaphoric reference when context exceeds the window?
This explores what happens to back-pointing references — pronouns and phrases like 'it,' 'that approach,' 'the earlier point' — when the thing they point back to (the antecedent) gets pushed out of, or buried deep inside, a model's context window.
This is really a question about antecedents: anaphora only works if the model can still 'see' the earlier mention a word points back to. The corpus suggests the failure starts long before you actually overflow the window. Reasoning accuracy drops from 92% to 68% with just 3,000 tokens of padding — far below capacity — and the degradation is task-agnostic and survives chain-of-thought prompting Does reasoning ability actually degrade with longer inputs?. So 'exceeding the window' is the dramatic version of a problem that's already underway: the farther back an antecedent sits, the shakier the link to it becomes.
The mechanism behind why some links survive and others snap is surprisingly concrete. Fewer than 5% of attention heads do the actual work of reaching back and fetching a specific fact from earlier context — and these 'retrieval heads' are causally necessary for getting the reference right. Prune them and the model hallucinates a plausible referent even when the real one is still sitting in the context What mechanism enables models to retrieve from long context?. That's the tell for what happens when an antecedent falls out of reach entirely: rather than say 'I've lost track of what this refers to,' the model confidently invents a referent. Anaphora doesn't fail loudly; it fails by confabulation.
There's a structural reason this can't be patched away. A model processes a whole conversation as one flat token string with no compartmentalized memory, so it faces a genuine dilemma — compress and you collapse distinct contexts together, keep things separate and you lose the threads that let a later 'it' bind to an earlier 'it.' Longer windows, compression, and retrieval each trade one failure mode for another How do LLMs balance remembering context versus keeping it separate?. Dialogue research sharpens the picture: rigid stack-based memory loses a topic the moment it's 'popped,' so when a conversation circles back, the antecedent is just gone; flexible attention does better precisely because it can reach any earlier turn — until that turn drifts out of effective range Why do dialogue systems lose context when topics return?.
Here's the part you might not have known you wanted: ChatGPT already leans anaphoric by temperament. It defaults to pointing backward — summarizing what was just said — where human writers more often point forward, previewing what's coming, and this likely falls out of generating one token at a time Does ChatGPT organize text differently than human writers?. So a model is structurally biased toward exactly the kind of reference that long context most threatens. The compounding worry is that even when the antecedent is present, strong training-time associations can override what's in the window, so the model resolves a reference to its priors rather than to the text in front of it Why do language models ignore information in their context?.
The most interesting escape route reframes the whole setup: instead of stuffing everything into attention and hoping the back-references hold, treat the long prompt as an external environment the model queries on demand — storing it in a code workspace and looking things up — which sidesteps attention degradation and handles inputs orders of magnitude past the window Can models treat long prompts as external code environments?. In that framing, resolving 'it' stops being a memory problem and becomes a lookup problem.
Sources 7 notes
FLenQA shows reasoning accuracy drops from 92% to 68% at just 3000 tokens of padding, far below context window capacity. The degradation is task-agnostic, uncorrelated with language modeling performance, and persists even with chain-of-thought prompting.
Less than 5% of attention heads across all model families function as retrieval heads, are intrinsic to short-context models, dynamically activate by context, and are causally necessary for factuality. Pruning them causes hallucination despite information being present in context.
Because LLMs process conversation as a single token string without compartmentalized memory, they cannot maintain separate contexts the way humans do. Existing mitigations like compression, longer windows, and retrieval all introduce new failure modes and cannot replicate human compartmentalization.
Research shows stack-based dialogue structures lose context when popped topics are revisited, while transformer attention enables systems to retrieve any previous turn without structural loss. Attention-based approaches naturally support the interleaved, revisiting nature of human conversation.
ChatGPT defaults to summarizing what was already said, while students use more forward-pointing structure that previews upcoming arguments. This reflects different reader models and may stem from how autoregressive generation works token by token.
Research demonstrates that LMs generate outputs inconsistent with their context because parametric knowledge from training dominates over in-context information. Textual prompting alone cannot override strong priors; causal intervention in representations is required.
Recursive Language Models store long prompts in a Python REPL and query them via code execution, avoiding attention degradation. RLMs outperform base models even on shorter prompts while handling inputs two orders of magnitude beyond context windows.