SWE-agent-LM: Autonomous Code Patch System

• SWE-agent-LM is an autonomous language model-based system designed to iteratively explore code, plan fixes, and execute patches within an interactive coding environment.
• It integrates key tools such as file navigation, code editing, and test execution while leveraging reinforcement learning and process reward models for efficient bug resolution.
• The framework utilizes expert trajectories and on-policy corrections to mitigate covariate shift and enhance metrics like pass@1 in real-world software engineering tasks.

A SWE-agent-LM (Software Engineering Agent—LLM) is an autonomous system powered by LLMs that performs end-to-end, multi-turn software engineering tasks within an interactive coding environment (Yang et al., 2024, Zhang et al., 28 Apr 2026). These systems act as automated software engineers: given a natural language issue description and a code repository (with executable runtime and tests), the agent iteratively explores code, plans and applies patches, and uses tools such as editors, shell commands, and test runners to resolve complex real-world issues.

1. Core Definition and Architecture

A SWE-agent-LM consists of a LLM policy πθ, coupled to an agent–computer interface (ACI) exposing file viewing, code editing, repository navigation, and script or test execution tools. At each turn, the agent receives the prior context (up to a maximum history), generates a plan or “thought,” emits an action command, receives structured observations, and continues until issuing a termination signal (e.g., “submit”) (Yang et al., 2024, Pan et al., 2024). The environment enforces sandboxing and supplies finely-grained, real-world feedback (e.g., unit test failures, linter errors).

SWE-agent-LMs typically implement a ReAct loop:

$\mathbf{x}$8

Key interfaces include:

• File Viewer: open, scroll, and search with concise summaries; controls context window bloat.
• Code Editor: atomic patches, linting, and edit reversion.
• Navigation/Search: file and directory lookup, grep-like search.
• Execution: arbitrary bash/python commands, submission for validation (Yang et al., 2024).

Recent extensions introduce Viewer and Editor subagents to decouple “what to edit” from “how to edit,” reducing context pollution and format interference, and use RL to learn adaptive editing format policies (Zhang et al., 28 Apr 2026).

2. Training Paradigms and Data Pipelines

Supervised Fine-Tuning and Trajectories

SWE-agent-LMs are fine-tuned on trajectories derived from expert (human or strong model) interactions: each trajectory encodes a sequence of (observation, action) pairs ending in a successful patch as measured by unit tests (Pan et al., 2024, Wang et al., 9 Jun 2025). Datasets such as SWE-smith (50k+ bug-fix tasks from 128 real-world repos) (Yang et al., 30 Apr 2025) and SWE-Gym (2,438 validated instances from 11 OSS projects) (Pan et al., 2024) provide large-scale, executable, and diverse task pools.

The fine-tuning objective is

$$\mathcal{L}_{FT}(\theta) = -\mathbb{E}_{(\mathbf{x},\mathbf{y}) \sim \mathcal{D}_{\text{traj}}} \log \pi_\theta(\mathbf{y}|\mathbf{x})$$

where $\mathbf{x}$ is the flattened context (issue + observations) and $\mathbf{y}$ is the agent output.

Trajectory datasets are filtered for high reward (all tests passing), and trajectory diversity is increased via temperature sampling and repository curriculum strategies (Pan et al., 2024).

Addressing Covariate Shift

Covariate shift arises when a policy visits states unseen in the expert data distribution during multi-turn interactions, degrading generalization (Lauffer et al., 16 Dec 2025). On-policy expert corrections (OEC), inspired by DAgger, mitigate this by switching from the student to the expert at random points in rollouts, combining on-policy histories with expert completions, and filtering the resulting set by unit test success. This hybrid distribution supports improved agent robustness.

The loss is masked to student-generated turns, and only expert states contribute to the supervised loss:

$$\mathcal{L}(\theta) =\mathbb{E}_{H\sim\mathcal{D}_{\mathrm{OEC}}} \biggl[\sum_{t=k+1}^{T}-\log \pi_\theta\bigl(A_t^\ast\mid h_{1:t}\bigr)\biggr]$$

(Lauffer et al., 16 Dec 2025) shows OEC+behavioral cloning improves resolve rates by 13–14% relative to vanilla imitation.

RL, Process Rewards, and Test-Time Scaling

Reinforcement learning is applied either with execution outcome rewards (Wang et al., 9 Jun 2025), or with more informative process-based rewards (rubrics) (Han et al., 16 Apr 2026). PRMs (Process Reward Models) score trajectories not just on pass/fail, but also on intermediate criteria such as progress toward correct functional region, efficiency, and lack of redundancy.

Rubric-based RL employs an auxiliary agent to generate issue-specific rubrics and applies memory-augmented updates:

$$R(\tau) = \begin{cases} (1-\gamma)\,s_{\text{prm}}(\tau, R_x) & \text{if fail} \ \gamma + (1-\gamma)\,s_{\text{prm}}(\tau, R_x) & \text{if pass} \end{cases}$$

with $s_{\text{prm}}$ the rubric-based process score (Han et al., 16 Apr 2026).

At inference, the PRM is reused to prune or rescore candidate actions, enabling latency-efficient, heuristic-guided rollouts (HG-TTS). On SWE-bench Verified, these strategies increase pass@1 rates while reducing token and compute consumption.

3. Agentic Workflow and Execution Strategies

SWE-agent-LMs implement repository-level, multi-hop workflows encompassing:

1. Environment setup: parse project, tests, and environment;
2. Exploration: navigate codebase, search for symptom-related code regions;
3. Planning: synthesize repair plans or edit maps;
4. Edit execution: perform code modifications (whole-file or region-specific);
5. Validation: invoke tests or scripts, analyze outcomes;
6. Iterative refinement: react to error feedback, update plans;
7. Submission: terminate upon successful patch and submit for final evaluation.

Decoupling of viewing (context extraction) from editing (execution) has been shown to yield 2.1 p.p. higher resolve rates and 17.9% lower inference cost (Zhang et al., 28 Apr 2026). Adaptive editing policies select between find-replace and whole-file-rewrite modes by maximizing a normalized match reward (Zhang et al., 28 Apr 2026).

Advanced variants such as SE-Agent implement evolutionary trajectory optimization, applying operations such as revision (self-reflection), recombination (cross-trajectory fusion), and local refinement to escape local optima and increase solution diversity (Lin et al., 4 Aug 2025).

4. Information Signal Prioritization

The ORACLE-SWE framework systematically quantifies the marginal and joint value of five oracle information signals:

• $s_1$: Reproduction Test
• $s_2$: Regression Test
• $s_3$: Edit Location
• $s_4$: Execution Context
• $\mathbf{x}$0: API Usage

Empirical analysis across state-of-the-art LMs and datasets finds the ordering of normalized marginal contribution to be:

$\mathbf{x}$1

Typical single-signal gains: $\mathbf{x}$2 (+24–28%), $\mathbf{x}$3 (+9–14%), $\mathbf{x}$4 (+8–14%), $\mathbf{x}$5 (+6–12%), $\mathbf{x}$6 (+2–6%) (Li et al., 9 Apr 2026). Perfectly extracted combinations reach >97% success.

Pairwise synergies (e.g., Reproduction Test + Edit Location) show super-additive effects, highlighting the importance of tightly coupling test outcomes with localization.

Design recommendations:

• Invest in reproduction-test generation and extraction.
• Instrument for native stack traces.
• Integrate test-guided fault localization.
• Augment for internal API knowledge; deprioritize regression-only workflows.

These findings directly inform training, prompting, and tool design for SWE-agent-LM architectures (Li et al., 9 Apr 2026).

5. Evaluation Methodologies and Benchmarks

Evaluation is grounded in realistic, repository-level settings with authentic issue descriptions, full codebases, runnable Dockerized environments, and rigorous unit test criteria. Key benchmarks:

• SWE-bench Verified: 500 (Python) real-world bug-fixing tasks.
• SWE-Gym: 2,438 curated OSS tasks with agent trajectories (Pan et al., 2024).
• SWE-smith: 50,000+ generated “fail-to-pass” test instances (Yang et al., 30 Apr 2025).
• SWE-Compass: 2,000 multi-language PR-derived tasks covering feature, enhancement, refactoring, performance, config, testing, and code comprehension (Xu et al., 7 Nov 2025).

Common metrics:

• Resolve rate/pass@1: fraction of issues where tests pass after one patch.
• pass@k: likelihood of at least one successful patch among k samples.
• Steps to solution, token and energy consumption.
• Cost per instance, patch generation rate.
• Trajectory-level measures: step repetition, context overflow, patch format correctness.

Verifiers (autograded or LM-based) may re-rank best-of-k rollouts (Pan et al., 2024). Code editing benchmarks (e.g., PR-Edit) allow rapid subcomponent evaluation and correlate strongly ($\mathbf{x}$7) with end-to-end agent performance (Zhang et al., 28 Apr 2026).

6. Performance, Limitations, and Design Principles

State-of-the-art SWE-agent-LMs such as SWE-agent-LM-32B (Qwen 2.5 Coder Instruct 32B, SFT on expert trajectories) achieve 40.2% pass@1 on SWE-bench Verified, narrowing the gap relative to closed-source LMs (e.g., GPT-4o ≈ 38.8%, Claude 3.7 Sonnet + SWE-agent 58.2%) (Yang et al., 30 Apr 2025). Kimi-Dev (72B) exceeds 48.6% pass@1 after agentic SFT (Yang et al., 27 Sep 2025), and rubric-optimized models (SWE-TRACE-30B + HG-TTS) reach 71.2% (Han et al., 16 Apr 2026).

Observed limitations:

• Small models (<4B) exhibit near-zero pass rates and waste energy in unproductive loops (Tripathy et al., 10 Dec 2025).
• Context window overflows, repetitive actions, and missing verifications are dominant failure modes.
• Covariate shift during multi-turn rollouts reduces generalization if not properly mitigated (Lauffer et al., 16 Dec 2025).
• Agent skills (injected procedural knowledge) show only limited, domain-specific gains (Han et al., 16 Mar 2026).
• Environments and test oracles remain fragile to external dependencies and incomplete coverage.

Best practices and design patterns:

• Architect prompt and tool interfaces that minimize format collisions and repetitive steps.
• Apply rejection-sampling and hybrid on-policy/off-policy fine-tuning.
• Use process reward models for real-time course correction (Gandhi et al., 2 Sep 2025).
• Structure agent workflows to decompose viewing, planning, and editing (Zhang et al., 28 Apr 2026).
• Leverage fine-grained rubrics and memory buffers during RL for long-horizon tasks (Han et al., 16 Apr 2026).
• Select skills and in-context hints for concrete, version-compatible procedural content (Han et al., 16 Mar 2026).

7. Future Directions and Frontier Forecasts

Forecasting indicates that non-specialized SWE-agent-LMs will reach 54% success on SWE-bench Verified by early 2026, and high-elicitation agents (state-of-the-art scaffolds, multi-sample inferencing) could reach 87% (95% CI: 83–92%) (Pimpale et al., 21 Feb 2025). Continued advances will likely arise from:

• Improved data curation, especially for environment buildability.
• Multimodal/GUI and cross-language pipeline extensions.
• Integrated RL with dense, process-based rewards and dynamic memory control.
• Efficient, inference-time strategy grafting (self-evolution, process reward intervention) (Lin et al., 4 Aug 2025, Gandhi et al., 2 Sep 2025, Han et al., 16 Apr 2026).
• Dynamic agent composition (e.g., locate-suggest-fix, proposal pipelines) (Zhang et al., 27 Feb 2026).

Challenges remain regarding scaling to underrepresented languages, multi-module repositories, robust generic test oracles, and scaling agentic frameworks to resource-constrained (SLM) regimes while maintaining cost and latency efficiency (Tripathy et al., 10 Dec 2025, Xu et al., 7 Nov 2025).

---

References

• (Yang et al., 2024) SWE-agent: Agent-Computer Interfaces Enable Automated Software Engineering
• (Pan et al., 2024) Training Software Engineering Agents and Verifiers with SWE-Gym
• (Yang et al., 30 Apr 2025) SWE-smith: Scaling Data for Software Engineering Agents
• (Wang et al., 9 Jun 2025) SWE-Dev: Building Software Engineering Agents with Training and Inference Scaling
• (Lin et al., 4 Aug 2025) SE-Agent: Self-Evolution Trajectory Optimization in Multi-Step Reasoning with LLM-Based Agents
• (Yang et al., 27 Sep 2025) Kimi-Dev: Agentless Training as Skill Prior for SWE-Agents
• (Xu et al., 7 Nov 2025) SWE-Compass: Towards Unified Evaluation of Agentic Coding Abilities for LLMs
• (Tripathy et al., 10 Dec 2025) SWEnergy: An Empirical Study on Energy Efficiency in Agentic Issue Resolution Frameworks with SLMs
• (Lauffer et al., 16 Dec 2025) Imitation Learning for Multi-turn LM Agents via On-policy Expert Corrections
• (Zhang et al., 27 Feb 2026) SGAgent: Suggestion-Guided LLM-Based Multi-Agent Framework for Repository-Level Software Repair
• (Han et al., 16 Mar 2026) SWE-Skills-Bench: Do Agent Skills Actually Help in Real-World Software Engineering?
• (Li et al., 9 Apr 2026) ORACLE-SWE: Quantifying the Contribution of Oracle Information Signals on SWE Agents
• (Han et al., 16 Apr 2026) SWE-TRACE: Optimizing Long-Horizon SWE Agents Through Rubric Process Reward Models and Heuristic Test-Time Scaling
• (Zhang et al., 28 Apr 2026) SWE-Edit: Rethinking Code Editing for Efficient SWE-Agent
• (Gandhi et al., 2 Sep 2025) When Agents go Astray: Course-Correcting SWE Agents with PRMs
• (Pimpale et al., 21 Feb 2025) Forecasting Frontier LLM Agent Capabilities