SWE-AGILE: A Software Agent Framework for Efficiently Managing Dynamic Reasoning Context

1. Problem Statement

Autonomous Software Engineering (SWE) agents face a fundamental dilemma when attempting to leverage System-2 reasoning (deep, analytical Chain-of-Thought) for complex, multi-turn tasks:

• Context Explosion & "Lost-in-the-Middle": Retaining full reasoning history (Interleaved Thinking) leads to massive context windows. This causes performance degradation due to attention dilution (the model struggles to retrieve relevant info from the middle of long sequences) and excessive GPU memory usage.
• Redundant Re-reasoning: Discarding historical reasoning to save context forces the agent to re-analyze the entire problem state at every step, leading to token inefficiency and cognitive amnesia.
• Training-Inference Mismatch: Standard training assumes a contiguous sequence where all history is visible. However, dynamic inference requires hiding past detailed reasoning to fit context limits, creating a gap that causes standard models to fail when deployed with context constraints.

2. Methodology: SWE-AGILE

SWE-AGILE is a framework designed to bridge the gap between reasoning depth, efficiency, and context constraints. It operates through three core components:

A. Dynamic Reasoning Context Strategy

Instead of keeping full history or discarding it entirely, SWE-AGILE employs a hybrid approach:

• Sliding Reasoning Window: Maintains a "Last-N-Steps" window of detailed reasoning traces ($r_t$) to ensure cognitive continuity and prevent redundant re-analysis.
• Reasoning Digests: Historical reasoning traces outside the sliding window are compressed into concise Reasoning Digests ($d_t$).
• Hybrid Context ($C_t$): The context fed to the model consists of the full history of observations/actions, but detailed reasoning is replaced by digests for steps outside the window.
  • Structure: $Y_t = r_t \oplus d_t \oplus a_t$ (Reasoning $\to$ Digest $\to$ Action).

B. Trajectory Snapshot Training

To resolve the training-inference mismatch, the authors propose decomposing long trajectories into discrete Snapshots:

• Frozen Context: In each snapshot, the input context simulates the inference state (historical reasoning is already compressed into digests). These tokens are visible to the model but masked from the loss function.
• Active Target: The model is only trained to predict the current step's reasoning ($r_t$), digest ($d_t$), and action ($a_t$).
• Benefit: This forces the model to learn to generate the next step based only on the compressed context available at runtime, rather than relying on full historical visibility.

C. Backfilling Reasoning and Digest Synthesis

Since existing SWE datasets often lack explicit System-2 reasoning, the authors developed a Hindsight Backfill pipeline:

• Process: A strong reasoning model (e.g., Qwen3-235B) takes successful raw trajectories (which often have shallow thoughts) and "backfills" them with detailed reasoning ($r_t$) and concise digests ($d_t$).
• Inputs: The synthesizer uses the Ground-Truth Action (future knowledge), the original shallow thought (intent), and the Dynamic Context constraints.
• Goal: To create high-quality, format-compliant training data that bridges the gap between shallow heuristics and deep problem-solving.

D. RLVR with Compression-Aware Optimization

The framework uses Reinforcement Learning with Verifiable Rewards (RLVR) to optimize the policy:

• Reward Function: $R(\tau) = I_{success} \cdot (1 + \beta \cdot \min(R_{comp}, \gamma))$.
  • $I_{success}$: Binary task success (ensures correctness is prioritized).
  • $R_{comp}$: Trajectory-Level Compression Rate, measuring the reduction in context tokens achieved by using digests instead of full reasoning.
• Global vs. Local: The reward uses a global trajectory-level metric rather than per-step averages. This prevents the model from "reward hacking" by inflating reasoning in simple steps; instead, it incentivizes deep reasoning for complex steps while aggressively compressing the final output.

3. Key Contributions

1. Dynamic Reasoning Context: A novel strategy using a sliding window for continuity and reasoning digests for long-term retention, solving the "Lost-in-the-Middle" issue without redundant re-analysis.
2. Trajectory Snapshot Training: A training paradigm that aligns the model's learning objective with the dynamic visibility constraints of inference, eliminating the training-inference mismatch.
3. Backfilling Data Synthesis: A pipeline to augment sparse SWE trajectories with explicit System-2 reasoning and structured digests, enabling training on small datasets (2.2k trajectories).
4. Compression-Aware RLVR: A reward mechanism that decouples reasoning depth from context cost, incentivizing the model to be a "deep thinker" when needed and a "concise distiller" for history.

4. Experimental Results

Evaluated on the SWE-Bench-Verified benchmark (500 tasks from 12 GitHub repos):

• Performance:
  • SWE-AGILE (SFT) on Qwen3-8B achieved a 21.45% success rate, a 35.5% relative improvement over the base model (15.83%).
  • SWE-AGILE (SFT + RLVR) reached 24.05%, outperforming all existing 7B/8B baselines and surpassing larger models like SkyRL-Agent-v0-14B (21.6%).
  • Applied to Qwen3-14B, it achieved 30.06%, significantly beating existing 14B baselines.
• Data Efficiency: Achieved these results using only 2.2k training trajectories (11% of the data used by SWE-Dev).
• Efficiency Analysis:
  • Context Management: SWE-AGILE reduced average reasoning length per step by ~28% compared to "Current-Step Thinking" baselines by utilizing digests as a cognitive cache.
  • Compression: The Compression Reward reduced textual summary (digest) length by 33.4% (from 41 to 27.3 tokens) while maintaining success rates.
  • Lost-in-the-Middle: The framework successfully mitigated the performance drop seen in "Interleaved Thinking" (full history) which scored only 12.42% on the 8B model.

5. Significance

• Scalability for Small Models: Demonstrates that small models (7B-8B) can achieve state-of-the-art performance in complex SWE tasks if equipped with efficient context management and explicit System-2 reasoning, challenging the notion that only massive models can handle deep reasoning.
• Resolving the Depth-Efficiency Trade-off: SWE-AGILE proves that reasoning depth and context constraints are not mutually exclusive. By decoupling transient reasoning overhead from permanent context retention, it achieves the Pareto frontier of performance and token efficiency.
• New Paradigm for Agentic Training: The "Snapshot Training" and "Backfilling" approaches offer a blueprint for training agents in long-horizon, multi-turn environments where context limits are a primary bottleneck.
• Future Directions: The framework opens avenues for optimizing cognitive efficiency by explicitly filtering redundant re-analysis and compressing tool outputs, moving beyond simple summarization to structured reasoning compression.