Context Collapse

The model loses the chronological ordering of events within a dialogue, treating past and present statements as if they occurred simultaneously. This often manifests when a user corrects a previous statement but the model continues to reference the outdated information.

• Mechanism: Failure of positional encoding to maintain sequence integrity over long contexts
• Example: User says 'I live in Berlin' in turn 1, then 'I moved to Tokyo' in turn 5; the model asks about Berlin in turn 10
• Root Cause: Attention dilution where older key-value pairs receive disproportionately high attention weights

The model merges attributes, knowledge, or statements from different speakers into a single blended persona. This is particularly dangerous in multi-user scenarios or when the model fails to distinguish between its own generated text and user-provided information.

• Mechanism: Absence of robust speaker diarization embeddings in the context representation
• Example: The model attributes a fact stated by User A to User B, or claims it generated content actually provided by the user
• Mitigation: Explicit role-tagging with ChatML or similar structured templates that enforce hard speaker boundaries

Distinct conversational topics bleed into one another, causing the model to generate responses that mix unrelated subjects. This occurs when the semantic separation between discourse segments collapses due to insufficient context segmentation.

• Mechanism: The attention mechanism creates spurious correlations between tokens from separate topical clusters
• Example: A discussion about project deadlines contaminates a subsequent discussion about lunch plans, resulting in 'The pasta deadline is approaching'
• Related Concept: Context Drift accelerates this erosion when the model fails to detect topic shifts

The model loses the distinction between high-priority system instructions and low-priority conversational content. When this hierarchy flattens, casual user statements can override carefully crafted behavioral constraints.

• Mechanism: Failure of attention masking to maintain differential weighting between system tokens and user tokens
• Example: A user jokingly says 'ignore all previous instructions' and the model complies because it cannot distinguish the utterance from a genuine system directive
• Related Term: This is a direct precursor to Prompt Injection vulnerabilities

When long conversations are summarized or compressed to fit within context window limits, critical distinguishing metadata is lost. The compression process strips away the structural scaffolding that maintains separation between dialogue segments.

• Mechanism: Lossy summarization that preserves semantic content but discards turn-level metadata and temporal markers
• Example: A compressed history states 'The user discussed budget concerns and approved the project' without indicating these happened in separate, contradictory contexts
• Mitigation: Structured summarization that explicitly preserves turn boundaries and speaker attribution

The model loses track of which entities are referenced by pronouns and definite descriptions across the dialogue. When coreference resolution fails, 'it', 'they', and 'that' become ambiguous, collapsing distinct referents into an undifferentiated mass.

• Mechanism: Degradation of the coreference graph that links mentions to entities over long contexts
• Example: User says 'The server is down' then 'Restart it'; model asks 'Restart what?' because the entity link between 'server' and 'it' has dissolved
• Related Concept: Lost in the Middle phenomenon exacerbates this for referents introduced mid-conversation

The maximum span of tokens a language model can attend to when generating a response. When the conversation history exceeds this limit, the model must truncate older information, creating conditions where temporal distinctions between early and late dialogue turns are lost. Modern models support windows from 128K to 1M+ tokens, but even large windows suffer from the lost in the middle phenomenon where centrally positioned information receives less attention.

The gradual deviation of a conversation from its original topic or intent. Unlike the sudden flattening of context collapse, drift is a slow erosion where each turn introduces semantically adjacent but divergent concepts. Key indicators include:

• The model responding to tangential keywords rather than the core objective
• Loss of intent carryover across turns
• Progressive dilution of the original system prompt constraints

The component that estimates the user's goal and belief state at every turn by aggregating dialogue history. Robust DST systems explicitly maintain a structured representation of slot-value pairs and user intent, creating a compressed semantic summary that resists collapse. When DST fails, the model reverts to treating each utterance as an isolated query, losing the thread of multi-turn interactions.

The NLP task of identifying all linguistic expressions that refer to the same entity. In a dialogue, pronouns like 'it' or 'that one' must be linked to their antecedents from earlier turns. When coreference resolution breaks down, the model conflates distinct entities—a direct pathway to context collapse where 'the Paris office' and 'the London branch' become indistinguishable in the model's attention.

The ability to fork a dialogue from a specific prior turn to explore alternative paths without corrupting the original session state. This technique actively prevents context collapse by maintaining immutable snapshots of the conversation tree. Each branch preserves its own temporal lineage, ensuring that returning to an earlier turn does not flatten the distinct histories of parallel explorations.

The process of extracting only the relevant snippets from a long context to fit within token limits without losing fidelity. Effective compression creates a semantic summary that preserves the distinct conversational threads, acting as a defense against collapse. Poor compression that simply truncates or naively summarizes can accelerate collapse by merging temporally distinct statements into an undifferentiated blob.