Technical Summary: Agentic Context Management for Long Horizon Tasks (ACM)

1. Problem Statement

Agentic tasks performed by Large Language Models (LLMs) are inherently long-horizon and multi-turn, requiring agents to formulate adaptive plans, invoke tools, and adjust actions based on environmental feedback. However, the interaction traces produced by these tasks accumulate verbose and noisy context (including failed attempts, redundant observations, and tool outputs). Even with models supporting nominal context windows of millions of tokens, the effective context capacity is often exceeded, leading to performance degradation.

Existing solutions face significant limitations:

• Long-context pretraining and hybrid attention mechanisms extend windows but suffer from measurable performance degradation or remain fundamentally bounded by context window limits.
• Context-compression pipelines (e.g., ReSum, ACON) rely on rigid, hand-crafted heuristic rules (such as fixed token thresholds) to trigger compression. These external monitors are misaligned with the agent's evolving reasoning focus, often compressing information prematurely or failing to compress when necessary. Furthermore, many compression methods are lossy, discarding original data that might be needed later.

2. Methodology: Agentic Context Management (ACM)

The authors propose Agentic Context Management (ACM), a framework that equips agents with purpose-built tools to manage their context autonomously, losslessly, and in alignment with their reasoning state.

2.1 Core Framework

Inspired by the separation of short-term and long-term human memory, ACM introduces two specific tools:

1. manage_context: Compresses the current working context (all messages since the last summary boundary) into a concise summary. Crucially, the original raw messages are not discarded but offloaded to an external persistent storage system (e.g., disk). Each summary is assigned a unique identifier mapping it to the raw data.
2. query_memory: Allows the agent to retrieve specific information from the offloaded raw messages by querying the external store using the summary identifier.

Unlike prior work where an external monitor forces compression, ACM is agent-initiated. The agent decides when and how to compress based on its internal reasoning state (e.g., detecting loops, redundant queries, or approaching token limits), enabling dynamic expansion or contraction of the effective context.

2.2 Post-Training Pipeline

Recognizing that frontier models struggle to determine the optimal timing for context management, the authors develop a dual-constraint teacher-student post-training pipeline:

• Phase 1: Student Rollouts: A student model (Qwen3.5-9B) generates trajectories under two conditions:
  • Without ACM tools ($H^-$): To reflect ordinary exploration behavior.
  • With ACM tools ($H^+$): To capture untrained usage of the tools.
• Phase 2: Teacher Annotation: A stronger teacher model (Qwen3.5-397B-A17B) reviews these trajectories against a reference answer and applies two complementary constraints:
  • Injection (on $H^-$): Identifies turns where context management should have been called (e.g., when the student enters a dead-end loop or accumulates redundant context) and inserts the appropriate tool call with a reasoning trace.
  • Refinement (on $H^+$): Identifies turns where the student's context management calls were premature or unnecessary (e.g., compressing before synthesizing an answer) and replaces them with more productive actions (e.g., deeper search or committing to an answer).
• Training Objective: The student is trained via on-policy distillation to match the teacher's soft next-token distributions, learning not only how to use the tools but when to invoke or refrain from them.

2.3 Data Quality Control

To ensure high-quality training data, the pipeline employs:

• Rejection Sampling: Retaining only trajectories where the student initially failed, ensuring learning occurs on genuinely challenging problems.
• Content Filtering: Verifying that teacher reasoning traces explain why compression is warranted (e.g., "cyclic exploration") without leaking information from the reference answer.

3. Key Contributions

1. Agentic Context Management Paradigm: A shift from external, heuristic-driven compression to an agent-autonomous, lossless context management system where the agent decides the timing and method of compression.
2. Dual-Constraint Post-Training Pipeline: An efficient method to internalize context management capabilities into the model itself, teaching the agent accurate timing for compression and retrieval without relying solely on heavy reinforcement learning.
3. Empirical Validation: Demonstration that effective context management reduces peak token pressure, extends test-time exploration turns, and improves solution consistency across independent trials.

4. Experimental Results

The authors evaluated ACM on three long-horizon benchmarks: BrowseComp-Plus, DeepSearchQA, and SWE-Bench Verified, using Qwen3.5-9B as the base model.

• Performance Gains:
  • BrowseComp-Plus: ACM-Post-Trained achieved a 72.7% Pass@1, a 27% relative improvement over the ReAct baseline (57.0%) and outperforming the 397B-parameter frontier model (65.3%).
  • DeepSearchQA: Improved from 36.7% (ReAct) to 42.5% (ACM-Post-Trained).
  • SWE-Bench Verified: Improved from 48.9% (ReAct) to 53.0% (ACM-Post-Trained).
• Efficiency and Behavior:
  • Token Reduction: ACM reduced peak token usage by approximately 20% compared to baselines, keeping the working context well below the limit even for long trajectories.
  • Exploration: The framework enabled significantly more tool calls and exploration turns. For instance, ACM-Post-Trained agents made more search and document retrieval calls than baselines, allowing them to traverse complex reasoning paths that would otherwise hit context limits.
  • Consistency: Analysis of Pass@K metrics revealed that ACM significantly narrows the gap between Pass@1 and Pass@4, indicating more consistent solutions across independent trials compared to the unstable ReAct baseline.
• Ablation Studies:
  • Distilling from a strong teacher alone (without specific ACM data) failed to surpass the ACM-trained model, highlighting the necessity of dedicated context management demonstrations.
  • Combining general distillation with ACM data yielded the best overall performance, suggesting the two sources are mutually reinforcing.

5. Significance and Claims

The paper claims that ACM represents a fundamental shift in how agents handle long-horizon tasks. By treating context management as an explicit, agent-initiated action rather than an external constraint, the framework allows agents to:

• Maintain a clean, compact working memory focused on immediate reasoning while preserving a lossless history in external storage.
• Extend their effective exploration horizon, solving problems that require hundreds of turns and hundreds of thousands of tokens, which would otherwise cause standard agents to fail due to context overflow or "lost in the middle" degradation.
• Achieve higher consistency, as a well-managed context reduces noise and prevents the agent from getting stuck in unproductive loops.

The authors emphasize that these gains are achieved without modifying the underlying model architecture or requiring massive-scale reinforcement learning, relying instead on a targeted post-training pipeline that teaches the model to manage its own cognitive resources.

Limitations: The authors note that ACM presupposes a base model with sufficient long-horizon reasoning capabilities; smaller models (e.g., 4B parameter) that terminate early due to reasoning collapse rather than context pressure do not benefit from these tools. Additionally, the evaluation relies on re-implemented baselines, though efforts were made to ensure fair comparison.