SWE-Edit: Rethinking Code Editing for Efficient SWE-Agent

1. Problem Statement

Current Large Language Model (LLM)-based Software Engineering agents face a fundamental problem of context coupling. Standard code editing interfaces conflate three distinct cognitive tasks within a single context window:

1. Code Inspection: Scanning files to understand context.
2. Change Planning: Reasoning about what needs to be changed.
3. Execution of Changes: Generating strictly formatted code changes (e.g., find and replace).

Main Problems:

• Context Pollution: As agents scan code to find relevant snippets, irrelevant information accumulates in the context window, degrading performance.
• Cognitive Conflict: The ability for broad thinking (exploration) conflicts with the need for precise, formatted generation (execution). Strong reasoning models often fail to produce correctly formatted changes, while strict formatting requirements lead to high failure rates.
• Inefficiency: Existing approaches use either error-prone "find and replace" (sensitive to whitespace) or prohibitively expensive "complete file rewrites".

2. Methodology: The SWE-Edit Framework

The authors propose SWE-Edit, a two-stage optimization framework that decouples the code editing process into specialized components.

A. Scaffolding Optimization (Architectural Decomposition)

The framework decomposes the monolithic agent into three distinct roles operating in clean, specialized contexts:

1. Main Agent: Focuses purely on problem-solving, orchestration, and high-level reasoning. It handles no raw file I/O or formatting.
2. Viewer Subagent:
   • Function: Receives a file path and a natural language query. Instead of returning raw file content, it extracts and delivers only the task-relevant code snippets.
   • Benefit: Eliminates context pollution by filtering out irrelevant code before it reaches the main agent. It uses a smaller, cost-efficient model.
3. Editor Subagent:
   • Function: Receives a file path and a high-level natural language instruction (e.g., "Refactor this function"). It executes the modification directly.
   • Benefit: Decouples high-level reasoning from low-level, format-sensitive code generation. This reduces formatting errors and allows the main agent to focus on logic rather than syntax.

B. Model Optimization (Adaptive Editing Strategy)

The authors investigate how the Editor Subagent can be effectively designed. They find that no single editing format works for all tasks:

• Find and Replace: Token-efficient for small, localized changes, but error-prone due to requirements for exact string matches.
• Complete File Rewrite: Robust for complex restructuring, but expensive and risky for large files.

Solution:

• Adaptive Mode Selection: The Editor is trained to dynamically choose between "Find and Replace" and "Complete File Rewrite" based on task complexity.
• Training Method: They use GRPO (Group Relative Policy Optimization) to train a Qwen3-8B model.
• Reward Signal: A Normalized Match Reward is used, which canonicalizes code (removes comments, normalizes whitespace) to compare the model's output with the ground truth without requiring full execution. This serves as a reliable proxy for editing correctness.

C. PR-Edit Benchmark

To avoid the high costs of end-to-end evaluation on SWE-bench for every iteration, the authors introduce PR-Edit, a lightweight benchmark derived from GitHub Pull Requests. It correlates strongly with downstream SWE-bench performance and serves as an efficient intermediate signal for selecting editor models.

3. Main Contributions

1. Decoupled Architecture: A novel triple decomposition (Main Agent + Viewer + Editor) that separates context inspection from change planning and execution, solving the context coupling problem.
2. Adaptive Editor Training: A Reinforcement Learning approach (GRPO) that teaches models to adaptively select the optimal editing strategy (Find-Replace vs. Rewrite) based on task complexity, outperforming static baselines.
3. PR-Edit Benchmark: A cost-effective benchmark that reliably predicts downstream agent performance, enabling rapid iteration on editor models without expensive full-repository tests.
4. Synergy of Cost and Performance: Demonstrates that structural decomposition can simultaneously improve accuracy and reduce inference costs, breaking the typical trade-off between accuracy and cost.

4. Experimental Results

Experiments were conducted on SWE-bench Verified (500 real GitHub issues).

• Performance Improvements:

  • Solve Rate: Improvement of 2.1% (from 69.9% to 72.0%) compared to the baseline.
  • Editing Reliability: The success rate for edits increased by 3.5% (from 93.4% to 96.9%).
  • Cost Reduction: Total inference costs decreased by 17.9% (from $243.7 to $200.1 per run).

• Component Analysis:

  • Viewer: Reduced context pollution, lowered uncached input tokens by approximately 34.5%, and reduced total costs alone by 7.7%.
  • Editor: Significantly improved edit success rates. Although it initially increased exploration (more Viewer calls), synergies with the Viewer compensated for these costs.
  • Adaptive Training: The GRPO-trained Qwen3-8B achieved edit success rates comparable to much larger proprietary models (GPT-5-nano) but at significantly lower costs. Scaling the editor model (e.g., from GPT-5-mini to GPT-5) yielded diminishing marginal returns compared to training for adaptive selection.

• Generalization: The framework showed consistent improvements across various reasoning models (Kimi-K2, MiniMax-M2.1, GLM-4.7), proving that the benefits are model-agnostic.

5. Significance

• Paradigm Shift: Moving away from monolithic agents toward specialized subagents for specific cognitive tasks (Viewing vs. Editing), addressing the "context coupling" bottleneck that limits current SWE agents.
• Practical Efficiency: Provides a blueprint for building cost-efficient agents. By using smaller, specialized models for specific tasks (Viewer/Editor) and a powerful model only for reasoning, organizations can achieve state-of-the-art results at a fraction of the cost.
• Training Insight: Highlights that format-level decisions (choosing how to edit) are a learnable capability that can be optimized via RL and often yields greater gains than simply increasing model size.
• Benchmarking: The PR-Edit benchmark offers the community a practical tool for evaluating and selecting editing models without the prohibitive costs of a full SWE-bench evaluation.

In summary, SWE-Edit demonstrates that structural decomposition and targeted model optimization are more effective levers for improving Software Engineering agents than simply scaling model parameters or relying on monolithic architectures.