Technical Summary: Diagnosing and Mitigating Context Rot in Long-horizon Search

Problem Definition

As Large Language Models (LLMs) are increasingly deployed in long-horizon agentic tasks, such as deep web search, they accumulate extensive context comprising both environment feedback and internal reasoning. This paper identifies a critical degradation in model performance known as context rot. Specifically, in deep search scenarios where agents execute tens or hundreds of tool calls, extensive context causes models to either directly give up (stating they cannot solve the problem) or prematurely provide uncertain answers (providing a clear answer while explicitly acknowledging unresolved uncertainty in their reasoning).

Unlike previous research focusing on single-turn long inputs (e.g., "needle-in-a-haystack" tests) or multi-turn human conversations, this work investigates context rot in multi-turn, multi-source, progressively accumulated agentic search tasks. The authors observe that as trajectory length increases, models do not merely lose accuracy; they shift their behavior toward these two specific failure modes, often becoming trapped in "struggle patterns" (repeated failed attempts or lack of progress).

Methodology

1. Diagnosis and Taxonomy

The authors developed a fine-grained taxonomy of terminal states to diagnose rot, categorizing agent outcomes into:

• Give Up: The agent explicitly states it cannot solve the problem.
• Uncertain Answer: The agent provides a clear answer but the reasoning explicitly indicates unresolved uncertainty.
• Confident Answer: The agent provides a clear answer with reasoning indicating satisfaction of all criteria.
• No Answer: The agent fails to output an answer due to context limits or turn budgets.

Using an LLM-as-a-judge (validated against human experts with 98.7% agreement), the authors evaluated four flagship open-source models (Qwen3.5-397B-A17B, GLM-4.7, GLM-5.0, MiniMax-M2.5) across three benchmarks: BrowseComp, BrowseComp-Plus (local corpus), and xbench-DeepSearch.

2. Pruning Analysis

To understand the relationship between accumulated context and rot, the authors conducted context pruning experiments. They systematically discarded different parts of the accumulated history (tool responses, reasoning content, or all context) while retaining the latest interaction window. This allowed them to isolate whether rot was caused by trajectory length, interaction turns, or the specific content of the accumulated context.

3. Mitigation Strategies

The paper evaluates two primary approaches to mitigate context rot:

A. Context Management (In-Process)
The authors systematically evaluated seven methods across three categories, modifying the ReAct framework:

1. Context Compaction: Periodically rewriting accumulated history into a compact summary. Triggers included trajectory length, interaction turns, and a "struggle score" (semantic detection of failure).
2. Context Trimming: Discarding previous content without rewriting. Variants included discarding all tool responses except the last, keeping only the latest interaction turns, and combining trimming with summarization.
3. Context Isolation: Using sub-agents (e.g., FoldAgent) to execute tasks and return only summarized outcomes, keeping the main agent's context window clean.

B. Post-Hoc Rejection Sampling
The authors developed a rot-aware filtering strategy. Multiple trajectories are generated for a single query using standard ReAct (without context management). A filter then excludes trajectories that terminate in "Give Up" or "Uncertain Answer" states, retaining only "Confident Answers" for aggregation (via majority voting, minimum length, or fewest turns).

Key Results

1. Characteristics of Context Rot

• Prevalence: Extensive context causes models to give up or provide uncertain answers, a phenomenon that worsens as context grows.
• Not Just Length: Rot is not solely dependent on trajectory length or the number of turns. Pruning experiments showed that removing accumulated context almost eliminates rot, but removing only reasoning or only tool responses (while keeping the other) still reduces rot, indicating the content of the accumulation matters.
• Struggle Correlation: Trajectories ending in rot states exhibit significantly higher "struggle scores" (repeated failures, no progress) compared to successful trajectories.
• Window Size vs. Performance: The context window size itself is not the primary bottleneck; models can solve problems within the window, but performance degrades due to how the model processes the accumulated context.

2. Effectiveness of Context Management

• Mixed Strategy is Optimal: A hybrid approach combining Context Trimming (keeping the latest turns) and Context Compaction (summarizing older content) achieved the best balance between cost (tool calls) and rot mitigation. Pure compaction reduced rot significantly but incurred high costs and unfinished trajectories; pure trimming was efficient but less effective at reducing rot.
• Model Dependency: Context isolation (sub-agents) showed high variance. It performed exceptionally well with strong backbones (e.g., Qwen3.5) but performed poorly with weaker models (e.g., GLM-4.7), suggesting it requires a robust LLM backbone to be effective.
• Trigger Frequency: Increasing the frequency of passive management (e.g., summarizing at shorter length thresholds) mitigated rot but increased costs and the rate of unfinished trajectories.

3. Effectiveness of Rejection Sampling

• Performance Gains: Applying rot-aware filtering to multiple sampled trajectories yielded an average performance gain of 2.6% to 4.9% across aggregation methods.
• Synergy: Combining rejection sampling with context management methods further improved performance. In datasets with severe rot (BrowseComp, BrowseComp-Plus), the best context management method combined with rejection sampling outperformed standard ReAct. In datasets with less severe rot (xbench-DeepSearch), standard ReAct with rejection sampling sometimes matched or exceeded context management methods.

Significance and Contributions

The paper claims the following contributions:

1. Diagnosis: It reveals a prevalent but previously unnoticed rot phenomenon in long-horizon agentic search, characterized by direct give-ups and premature uncertain answers, which is exacerbated by context growth.
2. Causal Analysis: Through pruning experiments, it demonstrates that rot is directly caused by accumulated context content, not merely trajectory statistics like length or turn count.
3. Systematic Evaluation: It provides a comprehensive evaluation of seven context management methods across three categories, offering clear guidance on strategy selection based on the trade-off between performance, cost, and rot severity.
4. Novel Mitigation: It introduces a rot-aware filtering strategy for rejection sampling, demonstrating its effectiveness in improving agent reliability without modifying the underlying agent framework.

The authors conclude that these insights provide a foundation for building more robust autonomous agents capable of handling increasingly complex, real-world long-horizon challenges by effectively managing the trade-offs between context retention and model degradation.