Context Management

Agents lose or misapply context over long conversations because system instructions become proportionally smaller as conversation history grows, conflicting instructions from multiple sources lack a declared resolution order, or state tracking breaks across session boundaries. These failures are silent: the agent still produces well-formed output, but it violates earlier constraints, forgets important decisions, or becomes confused about which instruction to follow when two sources conflict.

Key Takeaways

• 8 distinct failure patterns affect context handling, grouped into four mechanisms: instruction conflicts (contradictory directives from system/user/tools), context size limits (information loss when conversations exceed window), state tracking (loss or corruption of tracked variables/decisions), and session boundaries (confused state across multi-session workflows).
• Context management failures are nearly invisible at the point of failure — the agent’s output still looks correct, so the misapplied constraint or forgotten state only surfaces as a bug downstream when an external system or human reviewer catches the discrepancy.
• The reliable fix is architectural, not model-only: pre-execution conflict detection (before the agent acts on contradictions), periodic instruction re-injection (keep constraints at full attention weight throughout long conversations), external state stores (durability outside the context window), and explicit session-boundary handling.
• Instruction conflicts concentrate in multi-stakeholder systems where system-level constraints (security, compliance) must coexist with user-level instructions (persona, task-specific behavior) without a declared precedence rule.

Scope

• Instruction conflicts — conflicting-instructions. Multiple instruction sources (system prompt, user messages, tool outputs) contain contradictory guidance; agent resolves conflicts unpredictably instead of applying a declared hierarchy.
• Context size management — context-overflow, long-session-context-loss-violates-earlier-constraints. Large documents or long conversations exceed the context window; earlier instructions or critical requirements are truncated or summarized out, causing later references to be forgotten.
• State tracking degradation — instruction-drift, lost-state, memory-corruption, state-awareness. Agent loses track of decisions made earlier, forgets constraints as conversation grows, or corrupts tracked state so downstream logic fails.
• Session boundary confusion — cross-session-confusion. State from one session leaks into another; agent applies outdated decisions or person knowledge from past sessions to new unrelated conversations.

When Context Management Matters

• Agent manages state over long conversations (10+ turns), making decisions early that constrain behavior later, and relies on remembering those decisions
• Multiple instruction sources exist (system constraints, user messages, tool descriptions) and some may naturally conflict (security policy vs. user request for exception)
• Agent processes documents or conversation histories that approach or exceed the context window, and downstream logic depends on details from early in the document
• Agents run in multi-session or multi-tenant environments where context from prior sessions could leak into new conversations

Cross-Pattern Insight

None of the 8 context-management patterns are solved by simply making the agent “try harder” to follow instructions. The recurring mitigation across patterns is architectural separation: (1) maintain instructions in a separate store outside the context window so their weight doesn’t dilute as conversation grows; (2) maintain state in an external database rather than relying on context-based memory; (3) enforce explicit session boundaries so prior-session context cannot leak; (4) resolve instruction conflicts pre-execution via a policy engine rather than asking the agent to adjudicate contradictions. If a system implements only token-level optimizations (e.g., re-injecting instructions via prompting) without structural separation (external state store, policy engine), the mitigation is incomplete.

Frequently Asked Questions

How does context management differ from output accuracy failures?

Context management failures affect how the agent handles instructions and state, not the correctness of generated content. An agent following the wrong instruction due to a context conflict still produces well-formed output — the output simply violates a constraint the agent should have followed. Accuracy failures (hallucination, fabrication) cover generation of content not supported by any source. See Output Accuracy for fabrication and hallucination patterns.

What’s the difference between instruction drift and context overflow?

Instruction drift is when a constraint weakens gradually over a long conversation because it’s proportionally smaller in context (the model’s attention shifts toward recent turns). Context overflow is when information exceeds the hard window limit and is truncated, so later questions about early-conversation content cannot be answered at all. Drift is degradation of constraint influence; overflow is information loss.

Can you fix context management by increasing the context window size?

Increasing window size reduces the frequency of context overflow but does not solve the underlying problem. Instruction drift still occurs because attention patterns favor recent content regardless of window size. Conflicting instructions still lack a resolution order. State tracking still needs durability outside context. Window size is one knob among several architectural components needed for reliable context handling.

Which context management failures matter most for production systems?

Instruction conflicts (safety constraints violated due to user-level contradictions) and state tracking corruption (wrong decisions propagated to downstream systems) are highest-priority, as they directly undermine system safety and data integrity. Context overflow and instruction drift degrade performance gradually but are harder to detect because they’re not discrete failures — they manifest as gradual quality degradation.

Patterns

Total: 8 patterns

Related Goals

• Evaluation Reliability — golden-data problems that can surface context-management issues in testing
• Verification — testing approaches that catch context-management failures
• Output Accuracy — hallucination and confidence issues, separate from context-handling problems