SWE-Pruner: Self-Adaptive Context Pruning for Coding Agents

1. Problem Statement

Large Language Model (LLM) agents have shown remarkable potential in software engineering tasks, from code understanding to autonomous patch generation. However, their effectiveness is severely hampered by the "Context Wall":

• Token Accumulation: Real-world software repositories are massive. Agents navigating these repositories accumulate long interaction histories and raw file contents, quickly exhausting the context windows of even long-context models.
• Cost and Latency: Blindly ingesting large volumes of code leads to prohibitive API costs and high inference latency.
• Attention Dilution: Excessive context introduces noise, causing "attention dilution" and hallucinations, where the model loses focus on critical implementation details.
• Limitations of Existing Solutions: Current context compression methods (e.g., LongLLMLingua, Selective-Context) rely on static metrics like Perplexity (PPL) or self-information. These methods are task-agnostic and often operate at the token level, which disrupts the syntactic and logical structure of code, rendering it unusable for debugging or compilation. They fail to adapt to the dynamic, evolving goals of multi-turn agent interactions.

2. Methodology: SWE-Pruner

The authors propose SWE-Pruner, a self-adaptive context pruning framework designed specifically for coding agents. It operates as middleware between the agent and the environment, intercepting file-reading commands (e.g., cat, grep) to filter raw context before it reaches the LLM.

Core Components

1. Goal Hint Generation:

   • Instead of static compression, the agent is instructed to generate a Goal Hint—a natural language description of its current information need (e.g., "Focus on error handling logic in the Auth module").
   • This hint is passed as an optional parameter (context_focus_question) to the pruning system, enabling task-aware filtering.

2. Lightweight Neural Skimmer:

   • Architecture: A 0.6B parameter model based on Qwen3-Reranker-0.6B. It is designed for low latency and high efficiency.
   • Mechanism: The skimmer treats context pruning as a reranking problem. Given a query (Goal Hint) and a context (raw file content), it computes relevance scores.
   • Line-Level Granularity: Unlike token-level pruning, SWE-Pruner aggregates token scores to the line level. This ensures that syntactic structures (e.g., function definitions, class blocks) are preserved intact, preventing code breakage.
   • Training Objective: The model is trained using a Conditional Random Field (CRF) loss to model sequential dependencies between "retain" and "prune" decisions, ensuring coherent line-level retention. It also includes a document-level reranking head to maintain global relevance.

3. Training Data Construction:

   • Since no dataset exists with line-level relevance annotations for coding agents, the authors constructed a 61K-sample polyglot corpus using a teacher-student paradigm.
   • A teacher LLM (Qwen3-Coder-30B) synthesized task-oriented queries and line-level retention masks from GitHub repositories, covering nine distinct agentic tasks (e.g., debugging, refactoring, feature addition).
   • A "LLM-as-a-Judge" mechanism filtered the data to ensure high-quality annotations.

4. Integration Workflow:

   • The framework is integrated into agent loops (e.g., Mini SWE Agent, OpenHands). When an agent reads a file, the raw output is sent to the skimmer along with the Goal Hint. The skimmer returns a Pruned Context containing only the relevant lines, which the agent then processes.

3. Key Contributions

• Task-Aware Pruning Framework: Introduced a novel approach that dynamically adapts context compression based on the agent's specific reasoning goals, moving beyond static, content-only compression.
• Line-Level Structural Preservation: Designed a lightweight neural skimmer that operates at the line level, preserving syntactic validity and logical structure, which is critical for code correctness.
• Efficient Architecture: Developed a 0.6B parameter model that introduces negligible latency (<100ms) while achieving significant token reduction, making it practical for real-time agent workflows.
• Synthetic Data Pipeline: Created a rigorous pipeline for generating high-quality, line-level supervised data for code pruning, addressing a critical data gap in the field.

4. Experimental Results

The authors evaluated SWE-Pruner across four benchmarks: SWE-Bench Verified and SWE-QA (multi-turn agent tasks), and Long Code Completion and Long Code QA (single-turn tasks).

• Multi-Turn Agent Tasks (SWE-Bench Verified):

  • Token Reduction: Achieved 23–38% reduction in total token consumption.
  • Success Rate: Surprisingly, success rates improved by 1.2–1.4 percentage points (e.g., from 70.6% to 72.0% with Claude Sonnet 4.5).
  • Efficiency: Reduced interaction rounds by 18–26%, indicating that agents make more decisive decisions with focused context.
  • Cost: Significant reduction in API costs (up to ~36% savings).

• Single-Turn Tasks (Long Code QA/Completion):

  • Compression Ratio: Achieved up to 14.84× compression on Long Code QA under strict constraints, far outperforming baselines like LLMLingua2 and RAG.
  • Performance: Maintained or slightly improved accuracy (e.g., 58.71% accuracy at 14.84× compression) compared to full context, whereas token-level baselines suffered severe performance degradation under high compression.

• Efficiency & Latency:

  • The 0.6B skimmer adds minimal overhead (<100ms first-token latency), which is amortized by the massive reduction in downstream LLM decoding costs.
  • AST Correctness: SWE-Pruner maintained 87.3% AST correctness (syntactic validity), significantly outperforming token-level methods (which dropped to near 0% or <13%).

5. Significance

• Solving the Context Wall: SWE-Pruner provides a scalable solution to the context window limitations of coding agents, enabling them to navigate large, complex codebases without incurring prohibitive costs or losing focus.
• Paradigm Shift: It shifts context management from static compression to dynamic, goal-driven selection, mimicking how human developers "skim" code based on specific debugging or feature goals.
• Practical Viability: The framework is lightweight, model-agnostic (works with Claude, GLM, Qwen, etc.), and integrates seamlessly as middleware, making it immediately applicable to existing agent infrastructure.
• Quality over Quantity: The results demonstrate that less context is often better for coding agents, provided the retained context is structurally intact and semantically relevant to the current task. This challenges the prevailing "more context is better" assumption in long-context LLM research.