Organizations: International Research Center for Complexity Sciences, Hangzhou International Innovation Institute, Beihang University, Hangzhou, 311115, China · Department of Computer Science, College of Science, Mathematics and Technology, Wenzhou-Kean University, Wenzhou 325060, China · Fakulti Teknologi Maklumat dan Komunikasi, Universiti Teknikal Malaysia Melaka, Melaka 76100, Malaysia · Computer Systems Engineering Department, Sukkur IBA University, Sindh, Pakistan · Yibin Park of University of Electronic Science and Technology of China, Yibin 644000, China
Large language models generate plausible code but cannot verify correctness. Existing multi-agent systems simulate execution or leave verification optional. We introduce execution-grounded verification as a first-class principle: every code change must survive sandboxed execution before propagation. We instantiate this principle in AGENTFORGE, a multi-agent framework where Planner, Coder, Tester, Debugger, and Critic agents coordinate through shared memory and a mandatory Docker sandbox. We formalize software engineering with LLMs as an iterative decision process over repository states, where execution feedback provides a stronger supervision signal than next-token likelihood. AGENTFORGE achieves 40.0% resolution on SWE-BENCH Lite, outperforming single-agent baselines by 26--28 points. Ablations confirm that execution feedback and role decomposition each independently drive performance. The framework is open-source at https://github.com/raja21068/AutoCodeAI.
Figures & tables
Framework
Execution Feedback
Role Decomposition
Memory/Retrieval
AgentForge
Mandatory sandbox
5 roles (plan, code, test, debug, critic)
Dual (episodic + repo)
SWE-agent
Shell/ACI (optional)
Single agent
None
OpenHands
Sandbox (optional)
Single agent
None
Trae Agent
Test-time scaling
3 roles (gen, prune, select)
None
MAGIS
Implied
4 roles (mgr, custodian, dev, qa)
None
AgentMesh
None
3 roles (plan, debug, review)
None
TABLE I : Positioning Multi-Agent Frameworks Along Three Axes
Fig. 1 : Overview of the AgentForge multi-agent coding framework, illustrating the sequential handover between specialized agents and the shared Vector Memory.
Fig. 2 : Retrieval-Augmented Generation (RAG) architecture: (a) Offline repository indexing phase into the vector store; (b) Online semantic retrieval at inference time.
Fig. 3 : Isolated Docker sandbox execution environment. The 512 MB memory limit and disabled networking ensure security and reproducibility.
Method
Resolve Rate
Patch Rate
Single-agent GPT-4o
14.0%
12.5%
ReAct (GPT-4o)
12.0%
11.0%
SWE-agent [ 31 ]
18.1%
17.0%
AgentForge (ours)
40.0%
37.5%
TABLE II : Resolution rates on SWE-bench Lite (300 tasks). AgentForge outperforms single-agent baselines under a fixed execution budget.
Fig. 4 : Performance of AgentForge across three evaluation axes on SWE-bench Lite. Left: Resolution rate as a function of debug retries ( N ). Shaded regions denote ±1 standard deviation across runs. Iterative execution and repair yield consistent gains, with diminishing returns after N=2 . Center: Resolution under k independent runs with majority voting (Pass@k). Performance scales with k without increasing per-run complexity. Right: Cost–performance tradeoff. AgentForge achieves higher resolution at lower cost compared to single-agent baselines, indicating improved sample efficiency.
Configuration
Resolved
Resolve Rate
Full pipeline (ours)
42
42.0%
w/o Critic agent
38
38.0%
w/o Debugger agent
31
31.0%
w/o Tester agent
28
28.0%
w/o Planner agent
19
19.0%
Single-agent baseline
14
14.0%
TABLE III : Ablation study on 100 SWE-bench Lite tasks. Each row removes one agent from the pipeline.
Fig. 5 : Resolve rates across ablation conditions. Removing any single agent degrades performance; the Tester–Debugger loop is the largest contributor.
Failure Category
Count
Percentage
Faulty localization (incorrect file/line)
12
40.0%
Ineffective patch generation (wrong or partial fix)
TABLE IV : Failure mode analysis on 30 failed tasks.
Fig. 6 : Resolve rates across ablation conditions. Removing any single agent degrades performance; the Tester–Debugger loop is the largest contributor.
Configuration
Input tokens
Output tokens
Cost (USD)
Full pipeline
13,600
5,100
$0.1445
Single-agent (GPT-4o)
5,000
1,800
$0.054
TABLE V : Token usage and estimated API cost per task (averaged).
We introduce SWE-ZERO to SWE-HERO, a two-stage SFT recipe that achieves state-of-the-art results on SWE-bench by distilling open-weight frontier LLMs. Our pipeline replaces resource-heavy dependencies with an evolutionary refinement strategy: (1) SWE-ZERO utilizes large-scale, execution-free trajectories to master code semantics and repository-level reasoning, and (2) SWE-HERO applies targeted, execution-backed refinement to transition these semantic intuitions into rigorous engineering workflows. Our empirical results set a new benchmark for open-source models of comparable size. We release a dataset of 300k SWE-ZERO and 13k SWE-HERO trajectories distilled from Qwen3-Coder-480B, alongside a suite of agents based on the Qwen2.5-Coder series. Notably, SWE-HERO-32B achieves a 62.2% resolution rate on SWE-bench Verified. Furthermore, despite being trained exclusively on Python, our agents demonstrate robust zero-shot transferability on SWE-bench Multilingual, reaching 44.1% and confirming the paradigm's generalizability across diverse languages.
Nikolai Ludwig, Wasi Uddin Ahmad, Somshubra Majumdar +1
Coding agents are increasingly deployed for end-to-end software engineering tasks, where a readily available oracle evaluator that defines the success criteria is often absent. This motivates verifications for coding agents that can reliably judge and explain their behavior. However, verification is non-trivial as coding agents are increasingly capable of solving long-horizon software engineering tasks. Their execution trajectories can be extremely long, containing hundreds of iterative interactions with code repositories and external tools. Existing verifiers either rely on general-purpose LLMs without specialized training or train dedicated critics that predominantly focus on producing scalar rewards, highlighting the relatively limited exploration of training-based generalist verification. We introduce SWE-Critix, a post-training pipeline for training generalist verifiers of coding-agent trajectories. Given a task and its execution trajectory, the learned verifier predicts the completion label and generates a natural-language analysis that explains its judgment. Our pipeline combines supervised fine-tuning (SFT) with reinforcement learning (RL) and trains a series of 30B models on trajectories from CodeForge-Preview. On a held-out test set, SWE-Critix improves classification accuracy from 57% for the base Qwen3-30B-A3B reasoning model to 66% after SFT and 78% after RL. We release our models, datasets, and training code to facilitate further research.
Jiajun Hu, Chun Yong Chong
Leibniz Research Center, Huawei, Hong Kong SAR, China · School of Information Technology, Monash University Malaysia, Subang Jaya, Malaysia
DeepSWE is a benchmark of 113 original, long-horizon software engineering tasks for evaluating coding agents. Most public agentic coding benchmarks follow SWE-bench in mining merged fixes from public GitHub repositories, which creates two problems: the fixes and their discussion were likely seen during pretraining, so a high score can reflect recall rather than problem-solving; and each task is graded by the tests that shipped with its merged fix, which were written to confirm one specific fix rather than grade an arbitrary solution, so they can fail a correct alternative or pass an incomplete one. DeepSWE avoids both. Its tasks are written from scratch across 91 active open-source repositories and five languages and are never contributed back upstream, so their reference solutions stay out of the public record that model training scrapes; and each task is graded by a hand-written verifier that checks the requested functionality and accepts any implementation that provides it. When an independent LLM judge re-reviews graded runs, it disagrees with DeepSWE's verifier about an order of magnitude less often than with SWE-Bench Pro's inherited tests (1.4% versus 32.4%). Despite being about half the length of SWE-Bench Pro's prompts, DeepSWE's prompts describe tasks whose reference solutions touch 5.5x more code, and the benchmark separates frontier agents across a wider score band than the leaderboards on which they otherwise cluster. We release the benchmark, its verifiers, and the full record of evaluation trajectories.