Paper deep dive
SWE-Critix: Post-Training Generalist Verifiers for Assessing Coding-Agent Trajectories
Jiajun Hu, Chun Yong Chong
Intelligence
Status: succeeded | Model: Gemma-4-26B-A4B | Prompt: intel-v1 | Confidence: 93%
Last extracted: 10/14/2026, 9:34:14 AM
Summary
The paper introduces SWE-Critix, a post-training pipeline for training generalist verifiers of coding-agent trajectories. It combines supervised fine-tuning (SFT) and reinforcement learning (RL) on a Qwen3-30B model using data from CodeForge-Preview. The verifier predicts completion labels and generates natural language explanations, improving classification accuracy from 57% (base model) to 78% (after RL).
Entities (8)
Relation Signals (7)
SWE-Critix → achievesaccuracy → 78%
confidence 95% · SWE-Critix improves classification accuracy... to 78% after RL
SWE-Critix → trainedon → CodeForge-Preview
confidence 95% · trains a series of 30B models on trajectories from CodeForge-Preview
SWE-Critix → trains → Qwen3-30B-A3B
confidence 95% · trains a series of 30B models... improves classification accuracy from 57% for the base Qwen3-30B-A3B
SWE-Critix → uses → Supervised Fine-Tuning
confidence 95% · Our pipeline combines supervised fine-tuning (SFT) with reinforcement learning (RL)
SWE-Critix → uses → Reinforcement Learning
confidence 95% · Our pipeline combines supervised fine-tuning (SFT) with reinforcement learning (RL)
SWE-Critix → usesalgorithm → GRPO
confidence 90% · We use GRPO [46] with group size as 8 to optimize the objective
CodeForge-Preview → generatedby → OpenHands
confidence 85% · These trajectories were generated using the OpenHands scaffold
Cypher Suggestions (0)
No Cypher suggestions yet.
Abstract
Abstract: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.
Tags
Links
- Source: https://arxiv.org/abs/2610.13356v2
- Canonical: https://arxiv.org/abs/2610.13356v2
Trouble viewing inline? Open PDF directly →
Full Text
33,903 characters extracted from source content.
Expand or collapse full text
SWE-CRITIX: Post-Training Generalist Verifiers for Assessing Coding-Agent Trajectories Jiajun Hu Leibniz Research Center Huawei Hong Kong SAR, China hu.jiajun@huawei.com Chun Yong Chong School of Information Technology Monash University Malaysia Subang Jaya, Malaysia chong.chunyong@monash.edu Abstract—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. I. INTRODUCTION Recent advances in large language models (LLMs) have enabled a shift from code generation toward autonomous coding agents that can interact with environments to solve complex software engineering tasks. Rather than producing one-shot code snippets, coding agents can inspect repositories, edit files, execute commands, run tests, interpret feedback, and iteratively refine their solutions through interactions with external tools [1]–[3]. This agentic paradigm has substantially expanded the scope of automated programming from isolated function synthesis to repository-level issue resolution [4] and long-horizon software development tasks [5], [6]. As coding agents become more capable and autonomous, reliably verifying their execution trajectories (i.e., step-by- step record of an agent solving a task) becomes increasingly important. In realistic end-to-end tasks, the criteria for success- ful completion are often not explicitly specified by a readily available ground-truth oracle. A verifier is therefore needed to determine whether an agent has accomplished the task and, when it fails, identify the causes of failure. However, such verification is challenging because coding-agent trajectories TABLE I A 2D TAXONOMY OF CODING-AGENT VERIFIERS. OutcomeProcess Training-freeAgentless [7]; LLM-as-a-Verifier [8]; Trae [9]; Agentic Rubrics [10] SWE-PRM [11]; Wink [12]; TrajDebug [13]; SWE-Prime [14]; ProcCtrlBench [15] RETRACE [16]; LivePlan [17]; AgentLens [18]; Training-based Scalar SWE-Gym [19]; R2E-Gym [20]; DeepSWE [21]; SWE-RM [22]; Dockerless [23]; SWE-TRACE [24] OpenHands Critic [25]; Zainullina et al. [26]; Critic Rubrics [27] Training-based Generalist Agentic Rubrics [10]; ExecCritic [28]; SWE-Review [29] Gandhi et al. [30]; Scout [31];SWE-Critix can contain hundreds of interleaved user inputs, environment feedback, and model responses, making them substantially more difficult to inspect than a one-shot model response. For instance, trajectories for tasks in LoLBench [6] span 53–532 turns and contain millions of tokens on average. To address the challenge, existing work have proposed dif- ferent techniques from two orthogonal dimensions: verification target and method, as summarized in Table I. The former distinguishes whether a verifier evaluates only the agent’s final outcome (e.g., the submitted patch) or also examines the process to detect undesirable intermediate behaviors. The latter distinguishes whether a verifier is constructed with or with- out training. Training-free methods directly employ general- purpose LLMs or conventional rule-based judges, whereas training-based methods learn dedicated critics, which can be further characterized by whether they produce scalar rewards or richer natural-language assessments. This taxonomy reveals that training-based, process-oriented generalist verification remains relatively underexplored. To fill the gap, we propose SWE-CRITIX (Figure 1), a post- training pipeline that combines supervised fine-tuning (SFT) and reinforcement learning (RL) to train a generalist trajec- tory verifier. Given a task and its execution trajectory, the learned verifier not only determines whether the task has been successfully completed but also justifies the rationale arXiv:2610.13356v2 [cs.AI] 12 Oct 2026 2026/9/10 1 Te s tRLSFTtogether.ai/CodeForage_PreviewData Splits wrongcorrecttrajsissueswrongcorrecttrajsissueswrongcorrecttrajsissueswrongcorrecttrajsissues 188139655846811659465941318832211053105321061053952819533290614055R2E_Gym 40987774118721828143711437128742727217371737347417372020639199594059140SWE_Rebench 872517002257277059333803338066760280182405240548102405445108373512824535294SWE_Smith 1470428741434459698543455434510869038511519551951039051957424414246721671148489All CoT Annotation SFT RL Application Inference Framework: vllm_ascend_v0.19.1rc1 NPU: 16 * 910C-64GB (1 A3 node) Response <think> Let me analyze the trajectory carefully to evaluate whether the issue was successfully resolved. ## Step 1: Trajectory Summarization summary ## Step 2: Taxonomic Analysis 1. misunderstands specifications or instructions 2. v iolates minimal and localized change principles 3. d elivers incomplete code 4. i ntroduces core logical or algorithmic mistakes 5. f ails to correctly handle edge or boundary cases 6. violates library or API constraints 7. f ails to correctly handle exceptions or errors 8. d egrades performance or resource efficiency 9. c ompromises security or safety 10. breaks backward compatibility 11. misconfigures environment or infrastructure 12. undermines determinism or testability 13. compromises test or harness integrity 14-20. others ## Step 3: Casual Summary casual_analysis </think> <judgment>YES/NO<judgment> Coding agent trajectories Response <think> Step 1: Trajectory Summarization Step 2: Taxonomic Analysis Step 3: Casual Analysis </think> <judgment>YES/NO<judgment> RL Framework: VeRL v0.8.0 Inference Backend: vllm Training Backend: megatron Policy Gradient Algo: GRPO (Group=8) Global Batch Size: 32 Global Epochs: 1 (3396 Steps) Mini Batch Size: 32 PPO Epochs: 1 Max Prompt Len: 68K Max Response Len: 60K GEN_TP=4, GEN_DP=4, GEN_EP=16 TP=2, P=8, EP=16, ETP=1, CP=8 NPU: 128 * 910C-64GB (8 A3 nodes) 1 If judge==ground truth -1 otherwise reward= Coding agent trajectories SFT Framework: MindSpeed-LLM v2.3.0 Global Batch Size: 32 Sequence Length: 70K TP=2, P=2, EP=16, ETP=1, CP=16 Epochs: 3 (975 Steps) NPU: 128 * 910B1/2-64GB (16 A2 nodes) Prompt Template (Masked from Loss) <|im_start|>system system_prompt<|im_end|> <|im_start|>user instruction_of_correct_traj<|im_end|> <|im_start|>assistant Response Template (Contribute to Loss) <think> CoT_of_correct_traj </think> <judgment>YES</judgment><|im_end|> Prompt Template (Masked from Loss) <|im_start|>system system_prompt<|im_end|> <|im_start|>user instruction_of_wrong_traj<|im_end|> <|im_start|>assistant Response Template (Contribute to Loss) <think> CoT_of_wrong_traj </think> <judgment>NO</judgment><|im_end|> Issue Correct Trajectory Wrong Trajectory Trajectory Summary Taxonomic Analysis Casual Summary Trajectory Summary Taxonomic Analysis Casual Summary 1 Fig. 1. SWE-CRITIX Post-Training Pipeline and Data Splits. underlying its judgment. Compared with the two existing approaches in this category, SWE-CRITIX differs from them in terms of verification target (planning phase [30] vs. whole trajectory), annotation strategy (per-step dense labeling [31] vs. differential analysis), scale (2–8K training samples and 4– 8B models [30], [31] vs. 119K and 30B), learning algorithms (DPO [30] vs. GRPO), and reward design (process reward [31] vs. outcome reward). Using this pipeline, we train a Qwen3-30B MoE verifier on a distributed cluster equipped with Huawei Ascend NPUs, using coding-agent trajectories from CodeForge-Preview [32]. Our preliminary evaluation shows that the proposed post- training substantially improves the model’s ability to discrim- inate between successful and failed trajectories, increasing classification accuracy from 57% for the base model to 78% after reinforcement learning on the held-out test set. We open- source SWE-CRITIX on GitHub [33] and Hugging Face [34]. I. SWE-CRITIX Figure 1 shows the post-training pipeline of SWE-CRITIX, which learns an LLM (i.e., a generalist verifier) for evaluating coding-agent trajectories. The verifier takes an issue-solving trajectory as input and determines whether the issue has been successfully resolved. Before making the binary judgment, the verifier produces a chain-of-thought (CoT) rationale that casually infers its decision (Figure 1-Application). To train the verifier, SWE-CRITIX first applies a more capable teacher LLM to review a pair of successful and failed trajectories that address the same issue. Through differential analysis, the teacher summarizes the respective procedures, mistake patterns, and key factors leading to the success or failure of each trajectory (Figure 1-CoT Annotation). These summaries are then incorporated into a small amount of SFT training samples, providing supervision for the base model to learn the reasoning process underlying trajectory evaluation (Figure 1-SFT). Finally, RL is applied to a substantial number of samples without CoT annotations, where unit-testing results are used as ground truth for computing the reward signal (Figure 1-RL). A. Data Collection We collect test-verified trajectories from CoderForge- Preview [32], a large open dataset containing 258K trajec- tories (155K pass vs. 103K fail) spanning 51K issues across 1,655 repositories. These trajectories were generated using the OpenHands scaffold [35] with Qwen3-Coder-480B [36] as the underlying model, on three downstream task sources [20], [37], [38] that provide executable gym environments. We further prune the dataset by discarding any trajectory that exceeds 64K tokens or does not contain a submitted patch (e.g., the task is incomplete). After filtering out 16% of the data, we split the remaining trajectories into SFT, RL, and test sets as follows: 1. We randomly choose 20% of the issues and use all associ- ated trajectories as the test set. 2. Among the remaining issues, we randomly select one successful and one failed trajectory from each issue that contains both types, and assign them to the SFT set. 3. From the remaining trajectories, we include all failed trajec- tories in the RL set and then sample successful trajectories in a round-robin fashion across issues until the two classes are balanced. This maximizes the coverage of distinct issues. The resulting data is released on Hugging Face [34] and its statistics is summarized in Figure 1-Data Splits. B. Chain-of-Thought (CoT) Annotation It has been widely acknowledged that generating a CoT before providing the final answer significantly improves the performance of LLMs to resolve complex tasks [39]–[41]. To bootstrap the reasoning capabilities of our target verifier, SWE-CRITIX leverages a teacher LLM (GPT-5.5) to generate a structured CoT trace by comparatively analyzing each pair of successful and failed trajectories in the SFT set. We adopt this pairwise comparison approach based on prior findings that LLMs perform better in pairwise evaluations than in individual judgments [42], [43]. We then post-process the generated CoTs to adapt them for pointwise judgment, which is the intended evaluation setting for the trained verifier. The prompt templates and more details are released on GitHub [33]. The resulting CoT trace of a trajectory includes a concise summary of its issue-resolving procedure, a characterization of mistake patterns based on a predefined taxonomy, and a causal summary of the factors contributing to the success or failure of the trajectory. We apply CoT annotation only to the SFT set, which contains 10,390 trajectories and accounts for 8.7% of the training set. C. Supervised Fine-Tuning (SFT) We assemble the annotated CoTs into SFT samples using the templates shown in Figure 1-SFT, where the green and orange boxes represent the templates applied on successful and failed trajectories, respectively. We retain the thinking template of Qwen, as we choose to fine-tune from Qwen3-30B-A3B- Thinking-2507 that already possesses some reasoning capa- bilities [36]. We minimize the negative log-likelihood of the responses over the SFT set, which is the standard SFT cross- entropy loss: L SFT (θ) =−E (x,y)∼D SFT |y| X t=1 logπ θ (y t | x,y <t ) (1) where x denotes prompts and y denotes the corresponding response, including both the CoT and the final judgment. We use MindSpeed-LLM [44] to fine-tune the Qwen3 MoE model on 128 Huawei Ascend 910B1/B2-64GB NPUs across 16 nodes. Training for three epochs (975 iterations) takes approximately 15 hours. The SFT loss curve is illustrated in Figure 2. Training code and hyperparameter settings are avail- able on GitHub [33]. We denote the checkpoint at iteration 975 as π SFT and open-source its weights on Hugging Face [34]. 200400600800 0.6 0.8 1.0 1.2 1.4 LM Loss 50010001500200025003000 Iteration −0.2 0.0 0.2 0.4 0.6 0.8 Reward 100-step moving average Fig. 2. Training dynamics of SWE-CRITIX. The upper plot shows the LM loss during SFT, while the lower plot shows the reward during RL training. D. Reinforcement Learning (RL) The SFT stage utilizes a small fraction of the training data with CoT annotations to help the model learn the reasoning patterns before making the final judgment.To further enhance the model’s reasoning ability, we apply RL, a more powerful learning paradigm [45]–[47], to the remaining 91.3% of the training data, which contain unit-testing results but no CoT annotations. We follow the standard policy gradient algorithms to maximize the expected rewards obtained by a policy π θ : max π θ E x∼D RL ,y∼π θ (.|x) [r(x,y)]− βD KL [π θ ∥π SFT ](2) where the regularization termD KL prevents π θ from deviating too far from π SFT . We define a simple yet effective rule-based outcome reward: r(x,y) = +1, if y ans = YES∧ x traj passes tests +1, if y ans = NO∧ x traj fails tests −1, otherwise. (3) where x traj denotes the coding-agent trajectory in prompt x and y ans denotes the final answer extracted from the response y. A response receives a reward of +1 if its predicted judgment TABLE I PERFORMANCE COMPARISON OF QWEN3-30B-A3B, SWE-CRITIX SFT, AND SWE-CRITIX RL ON THE TEST SET AND ITS THREE SUBSETS. DatasetModelAccuracyPrecision+Recall+F1+Precision-Recall-F1- R2E-Gym Qwen3-30B-A3B 0.60 (3495/5846)0.68 (3483/5128)0.88 (3483/3965)0.770.80 (12/15)0.01 (12/1881)0.01 SWE-Critix SFT 0.52 (3027/5846)0.73 (1817/2488)0.46 (1817/3965)0.560.36 (1210/3358)0.64 (1210/1881)0.46 SWE-Critix RL0.62 (3646/5846)0.75 (2671/3577)0.67 (2671/3965)0.710.43 (975/2269)0.52 (975/1881)0.47 SWE-Rebench Qwen3-30B-A3B 0.56 (6675/11872)0.65 (6656/10170)0.86 (6656/7774)0.740.68 (19/28)0.00 (19/4098)0.01 SWE-Critix SFT 0.71 (8476/11872)0.84 (5369/6360)0.69 (5369/7774)0.760.56 (3107/5512)0.76 (3107/4098)0.65 SWE-Critix RL0.78 (9308/11872)0.87 (6158/7106)0.79 (6158/7774)0.830.66 (3150/4766)0.77 (3150/4098)0.71 SWE-Smith Qwen3-30B-A3B 0.56 (14417/25727) 0.66 (14397/21793) 0.85 (14397/17002) 0.740.80 (20/25)0.00 (20/8725)0.00 SWE-Critix SFT 0.66 (17018/25727) 0.76 (12154/16015) 0.71 (12154/17002) 0.740.50 (4864/9712)0.56 (4864/8725)0.53 SWE-Critix RL0.82 (20971/25727)0.82 (15670/19094)0.92 (15670/17002)0.870.80 (5301/6633)0.61 (5301/8725)0.69 All Qwen3-30B-A3B 0.57 (24587/43445) 0.66 (24536/37091) 0.85 (24536/28741) 0.750.75 (51/68)0.00 (51/14704)0.01 SWE-Critix SFT 0.66 (28521/43445) 0.78 (19340/24863) 0.67 (19340/28741) 0.720.49 (9181/18582) 0.62 (9181/14704) 0.55 SWE-Critix RL0.78 (33925/43445)0.82 (24499/29777)0.85 (24499/28741)0.840.69 (9426/13668)0.64 (9426/14704)0.66 is consistent with the ground truth derived from unit testing, and -1 otherwise. We use π SFT as the initial RL checkpoint and conduct RL training using 128 Huawei Ascend 910C-64GB NPUs across 8 nodes with VeRL [48]. We use GRPO [46] with group size as 8 to optimize the objective in Equation 2. One epoch consists of 3,396 iterations and takes approximately 533 hours to complete. The reward curve during training is shown in Figure 2. We refer to the resulting checkpoint as π RL and release its weights on Hugging Face [34]. I. PRELIMINARY EVALUATION As a preliminary evaluation, we focus on the model’s ability to distinguish between successful and failed trajectories. We evaluate π RL , π SFT , and the base Qwen3 MoE model on the test split created in Section I-A. We serve these models using vLLM Ascend [49] on one node containing 16 Huawei Ascend 910C-64GB NPUs. Given the large scale of the test set (over 43K long-trajectory samples), we evaluate each model on each sample only once. We report accuracy, as well as precision, recall, and F1 scores for both the positive (successful trajectory) and negative (failed trajectory) classes. We present the results in Table I. The results reveal a clear progression from general-purpose language modeling to specialized trajectory verification. The base Qwen3 MoE model exhibits a strong bias toward predicting trajectories as correct, as its negative recall is nearly zero across all subsets. It also has limited instruction following capability on this task. We observed that 9.6% of its responses do not adhere to the required output format, preventing reliable extraction of the predicted judgments. SFT substantially alleviates both issues. All responses produced by π SFT strictly follow the instructions required by the prompt, and the model becomes considerably less biased toward positive predictions. Further RL training yields another significant improvement, increasing accuracy from 66% after SFT to 78% on the overall test set. These results suggest that SFT primarily addresses the base model’s strong positive bias, while subsequent RL further strengthens its discriminative capability by recovering positive recall from 67% to 85% without substantially sacrificing negative recall. Despite these gains, two limitations remain. First, perfor- mance on R2E-Gym is notably lower than those on SWE- Rebench and SWE-Smith. One possible explanation is its relatively smaller data volume. Second, π RL remains less effective at recognizing failed trajectories as the negative recall reaches only 64% overall. This suggests that failed trajectories remain more challenging to distinguish from successful ones, potentially due to the greater diversity of failure patterns and the subtle failure signals that are difficult to identify. IV. FUTURE WORK Our current evaluation focuses on the discriminative ability of SWE-CRITIX . In future, we plan to conduct more com- prehensive evaluations along the following five dimensions. 1. Training Data: All samples in CodeForge-Preview [32] are generated using OpenHands [35] with Qwen3-Coder- 480B [36]. To investigate the impact of data mixtures, we plan to incorporate trajectories from other sources, such as Open- SWE-Traces [50], and synthesize trajectories using different combinations of LLMs and harnesses. Furthermore, beyond the balanced positive-to-negative ratio, we plan to investigate the effects of different class ratios, such as 2:1, 1:2, and 4:1. 2. Training Methods: It remains an open question whether RL alone is sufficient to train an effective verifier. We therefore plan to establish a cold-start RL baseline by removing the CoT annotation and SFT stages from our pipeline. In addition, we plan to conduct reward ablations in the RL stage by incorporating signals not only from the final test results but also from the intermediate reasoning process. 3. Downstream Applications: We plan to explore down- stream scenarios that can benefit from the trained verifier. For example, can the verifier help recover a correct solution by identifying and rectifying errors in a failed trajectory? Can the verifier serve as a proxy reward for RL training when ground-truth test results are unavailable? 4. Baselines: We plan to compare SWE-CRITIX with fron- tier open/closed-source models [51]–[53] and representative methods from the categories summarized in Table I. 5. Qualitative Analysis: Beyond the quantitative evalua- tions described above, we plan to conduct a qualitative analysis of the model’s reasoning traces to assess whether its analyses are logically coherent and grounded in evidence. We will also investigate cases in which the verifier makes incorrect judgments to better understand the sources of its errors. V. RELATED WORK Prior work proposing verifiers for reviewing coding-agent executions can be classified into two major categories depend- ing on whether a specialized verification model is trained. One is training-free verification, where an evaluator agent uses general-purpose LLMs to assess coding agent executions through test generation [7], [9], rubric-based grading [10]– [12], verification scaling [8], metamorphic relations [16], fail- ure attribution [13], or anti-pattern detection [14], [15], [17], [18]. Another major category is training-based verification, where a specialized critic is trained to evaluate trajectories using different learning paradigms such as TD learning [25], [26], autoregressive next-token prediction [10], [19]–[23], [28]–[31], multi-label classification [27], DPO [30], Bradley- Terry [24], and policy gradient [28], [31]. VI. CONCLUSION In this paper, we proposed a post-training pipeline SWE- CRITIX that integrates SFT with RL to learn a process- level generalist verifier for assessing coding-agent trajectories. Preliminary experiments on coding-agent trajectories from CodeForge-Preview demonstrate a substantial improvement in the model’s discriminative ability. REFERENCES [1] DeepSeek-AI,“Deepseekharness:Everythingisaplugin,” https://github.com/deepseek-ai/deepseek-harness, 2026. [2] Codex, https://openai.com/codex/, 2026. [3] Claude Code, https://claude.com/product/claude-code, 2026. [4] C. E. Jimenez, J. Yang, A. Wettig, S. Yao, K. Pei, O. Press, andK.R.Narasimhan,“SWE-bench:Canlanguagemodels resolve real-world github issues?” in The Twelfth International Conference on Learning Representations, 2024. [Online]. Available: https://openreview.net/forum?id=VTF8yNQM66 [5] X. Deng, J. Da, E. Pan, Y. Y. He, C. Ide, K. Garg, N. Lauffer, A. Park, N. Pasari, C. Rane, K. Sampath, M. Krishnan, S. Kundurthy, S. Hendryx, Z. Wang, V. Bharadwaj, J. Holm, R. Aluri, C. B. C. Zhang, N. Jacobson, B. Liu, and B. Kenstler, “Swe-bench pro: Can ai agents solve long-horizon software engineering tasks?” 2025. [Online]. Available: https://arxiv.org/abs/2509.16941 [6] Y. Peng, Z. Wu, Z. Zhuang, X. Zhou, R. Shu, X. Han, C. Y. Chong, Y. Wang, and J. Liu, “Lolbench: Evaluating coding agents with long-horizon proposals on large software systems,” 2026. [Online]. Available: https://arxiv.org/abs/2609.37143 [7] C. S. Xia, Y. Deng, S. Dunn, and L. Zhang, “Agentless: Demystifying llm-based software engineering agents,” 2024. [Online]. Available: https://arxiv.org/abs/2407.01489 [8] J. Kwok, S. Li, P. Atreya, Y. Liu, Y. Jiang, C. Finn, M. Pavone, I. Stoica, and A. Mirhoseini, “Llm-as-a-verifier: A general-purpose verification framework,” 2026. [Online]. Available: https://arxiv.org/abs/2607.05391 [9] T. R. Team, P. Gao, Z. Tian, X. Meng, X. Wang, R. Hu, Y. Xiao, Y. Liu, Z. Zhang, J. Chen, C. Gao, Y. Lin, Y. Xiong, C. Peng, and X. Liu, “Trae agent: An llm-based agent for software engineering with test-time scaling,” 2025. [Online]. Available: https://arxiv.org/abs/2507.23370 [10] M. Raghavendra, A. Gunjal, B. Liu, and Y. He, “Agentic rubrics as contextual verifiers for swe agents,” 2026. [Online]. Available: https://arxiv.org/abs/2601.04171 [11] S. Gandhi, J. Tsay, J. Ganhotra, K. Kate, and Y. Rizk, “When agents go astray: Course-correcting swe agents with prms,” 2025. [Online]. Available: https://arxiv.org/abs/2509.02360 [12] R. Nanda, C. Maddila, S. Jha, E. M. Khan, M. Paltenghi, and S. Chandra, “Wink: Recovering from misbehaviors in coding agents,” 2026. [Online]. Available: https://arxiv.org/abs/2602.17037 [13] Y. Qi, Z. Yin, X. Shi, H. Peng, S. Lu, Y. Liu, R. Xuan, Y. Liu, Z. Hu, X. Wang, L. Hou, B. Xu, and J. Li, “Trajdebug: Tracing error lifecycle to identify critical failures in long-horizon agent trajectories,” 2026. [Online]. Available: https://arxiv.org/abs/2608.06346 [14] D. Zheng, R. Ye, Y. Wang, Y. Ye, H. Zhang, E. Shi, X. Liu, Y. Ma, J. Yu, and Z. Zheng, “Swe-prime: Fewer trajectories, better performance,” 2026. [Online]. Available: https://arxiv.org/abs/2608.27449 [15] J. He, J. Jia, C. Liu, C. Xue, Y. Song, X. Yang, and D. Sun, “Procctrlbench: Evaluating process-level defects and control preservation in llm coding agents,” 2026. [Online]. Available: https://arxiv.org/abs/2605.20251 [16] C.Li,Y.Xu,Z.Wang,S.H.Tan,Tse-Hsun,and Chen, “Independent patch verification for coding agents with a bidirectional reconstruct-and-verify framework,” 2026. [Online]. Available: https://arxiv.org/abs/2608.08950 [17] S. Liu, S. Dehghan, J. Y. Kim, J. Ganhotra, M. Hirzel, and R. Jab- barvand, “Online monitoring and corrective steering of programming agents,” 2026. [Online]. Available: https://arxiv.org/abs/2608.06701 [18] P. Sahoo, G. Mittal, X. Li, S. Ma, B. Steenhoek, P. Lin, and Y. Hu, “Agentlens: Revealing the lucky pass problem in swe-agent evaluation,” 2026. [Online]. Available: https://arxiv.org/abs/2605.12925 [19] J. Pan, X. Wang, G. Neubig, N. Jaitly, H. Ji, A. Suhr, and Y. Zhang, “Training software engineering agents and verifiers with swe-gym,” 2025. [Online]. Available: https://arxiv.org/abs/2412.21139 [20] N. Jain, J. Singh, M. Shetty, L. Zheng, K. Sen, and I. Stoica, “R2e-gym: Procedural environments and hybrid verifiers for scaling open-weights swe agents,” 2025. [Online]. Available: https://arxiv.org/abs/2504.07164 [21] M. Luo, N. Jain, J. Singh, S. Tan, A. Patel, Q. Wu, A. Ariyak, C. Cai, T. Venkat, S. Zhu, B. Athiwaratkun, M. Roongta, C. Zhang, L. E. Li, R. A. Popa, K. Sen, and I. Stoica, “Deepswe: Training a state-of-the-art coding agent from scratch by scaling rl,” https://pretty-radio-b75.notion.site/DeepSWE-Training- a-Fully-Open-sourced-State-of-the-Art-Coding-Agent-by-Scaling-RL- 22281902c1468193aabbe9a8c59bbe33, 2025, notion Blog. [22] K. Shum, B. Hui, J. Chen, L. Zhang, X. W., J. Yang, Y. Huang, J. Lin, and J. He, “Swe-rm: Execution-free feedback for software engineering agents,” 2025. [Online]. Available: https://arxiv.org/abs/2512.21919 [23] W. Zeng, Y. Shi, X. Gu, C. Hu, C. Wang, Y. Cui, H. Zhou, M. Qi, J. Wangni, Z. Yu, S. Gao, K. Cai, and S. He, “Dockerless: Environment-free program verifier for coding agents,” 2026. [Online]. Available: https://arxiv.org/abs/2606.28436 [24] H. Han, J. Xie, X. Ma, W. Zhu, Z. Zhang, Z. Long, H. Chen, and Q. Ye, “Swe-trace: Optimizing long-horizon swe agents through rubric process reward models and heuristic test-time scaling,” 2026. [Online]. Available: https://arxiv.org/abs/2604.14820 [25] X. Wang. (2025, 4) Sota on swe-bench verified with inference-time scaling and critic model. OpenHands Blog. Blog post. [Online]. Available: https://w.openhands.dev/blog/sota-on-swe-bench-verified- with-inference-time-scaling-and-critic-model [26] K. Zainullina, A. Golubev, M. Trofimova, S. Polezhaev, I. Badertdinov, D. Litvintseva, S. Karasik, F. Fisin, S. Skvortsov, M. Nekrashevich, A. Shevtsov, and B. Yangel, “Guided search strategies in non- serializable environments with applications to software engineering agents,” 2025. [Online]. Available: https://arxiv.org/abs/2505.13652 [27] X. Wang, V. Chen, H. Ji, and G. Neubig, “A rubric-supervised critic from sparse real-world outcomes,” 2026. [Online]. Available: https://arxiv.org/abs/2603.03800 [28] L. Tao, B. Peng, H. Wang, H. Wang, H. Cheng, W. Yao, Q. Wu, T. Ge, S. Li, and J. Gao, “Execcritic: Learn to test, test to improve for coding agents,” 2026. [Online]. Available: https://arxiv.org/abs/2609.09133 [29] R. Wang, J. Chen, S. Wang, C. Tao, S. Yang, Y. Jiang, K.-H. Yap, L. Shang, X. Li, and H. Bai, “Swe-review: Closing the loop on issue resolution with agentic code review,” 2026. [Online]. Available: https://arxiv.org/abs/2607.06065 [30] S. Gandhi, Y. Xie, A. Naik, R. Zhu, and C. Rose, “Steer, don’t solve: Training small critic models for large code agents,” 2026. [Online]. Available: https://arxiv.org/abs/2606.21811 [31] S. Rahman, Y. Kim, M. Parmar, A. A. Heydari, G. Liu, S. A. Lee, W. Zhang, A. Hosseini, A. A. Metwally, Y. Yang, B. Mirzasoleiman, X. Liu, P. Izmailov, S. Gabriel, M. Malhotra, S. Patel, D. McDuff, and H. Palangi, “Locating hidden failures makes long-horizon agents more reliable,” 2026. [Online]. Available: https://arxiv.org/abs/2609.17930 [32] A. Ariyak, J. Zhang, J. Wang, S. Zhu, F. Bianchi, S. Srivastava, A. Panda, S. Bharti, C. Xu, J. Heo, X. S. Wu, J. Zou, P. Liang, L. Song, C. Zhang, B. Athiwaratkun, Z. Zhou, and Q. Wu, “Coderforge-preview: Sota open dataset for training efficient agents,” Feb. 2026, project core leads: Alpay Ariyak; Zhongzhu Zhou; Qingyang Wu. [Online]. Available: https://w.together.ai/blog/coderforge-preview [33] SWE-Critix GitHub, https://github.com/SWE-Critix/SWE-Critix, 2026. [34] SWE-Critix Hugging Face, https://huggingface.co/SWE-Critix, 2026. [35] X. Wang, B. Li, Y. Song, F. F. Xu, X. Tang, M. Zhuge, J. Pan, Y. Song, B. Li, J. Singh, H. H. Tran, F. Li, R. Ma, M. Zheng, B. Qian, Y. Shao, N. Muennighoff, Y. Zhang, B. Hui, J. Lin, R. Brennan, H. Peng, H. Ji, and G. Neubig, “Openhands: An open platform for ai software developers as generalist agents,” 2025. [Online]. Available: https://arxiv.org/abs/2407.16741 [36] Q. Team, “Qwen3 technical report,” 2025. [Online]. Available: https://arxiv.org/abs/2505.09388 [37] I. Badertdinov, A. Golubev, M. Nekrashevich, A. Shevtsov, S. Karasik, A. Andriushchenko, M. Trofimova, D. Litvintseva, and B. Yangel, “Swe- rebench: An automated pipeline for task collection and decontaminated evaluation of software engineering agents,” 2025. [Online]. Available: https://arxiv.org/abs/2505.20411 [38] J. Yang, K. Lieret, C. E. Jimenez, A. Wettig, K. Khandpur, Y. Zhang, B. Hui, O. Press, L. Schmidt, and D. Yang, “Swe-smith: Scaling data for software engineering agents,” 2025. [Online]. Available: https://arxiv.org/abs/2504.21798 [39] J. Wei, X. Wang, D. Schuurmans, M. Bosma, B. Ichter, F. Xia, E. Chi, Q. Le, and D. Zhou, “Chain-of-thought prompting elicits reasoning in large language models,” 2023. [Online]. Available: https://arxiv.org/abs/2201.11903 [40] M. Y. Guan, M. Joglekar, E. Wallace, S. Jain, B. Barak, A. Helyar, R. Dias, A. Vallone, H. Ren, J. Wei, H. W. Chung, S. Toyer, J. Heidecke, A. Beutel, and A. Glaese, “Deliberative alignment: Reasoning enables safer language models,” 2025. [Online]. Available: https://arxiv.org/abs/2412.16339 [41] X. Chen, G. Li, Z. Wang, B. Jin, C. Qian, Y. Wang, H. Wang, Y. Zhang, D. Zhang, T. Zhang, H. Tong, and H. Ji, “Rm-r1: Reward modeling as reasoning,” 2026. [Online]. Available: https://arxiv.org/abs/2505.02387 [42] A. Wettig, A. Gupta, S. Malik, and D. Chen, “Qurating: Selecting high-quality data for training language models,” 2024. [Online]. Available: https://arxiv.org/abs/2402.09739 [43] L. Ouyang, J. Wu, X. Jiang, D. Almeida, C. L. Wainwright, P. Mishkin, C. Zhang, S. Agarwal, K. Slama, A. Ray, J. Schulman, J. Hilton, F. Kelton, L. Miller, M. Simens, A. Askell, P. Welinder, P. Christiano, J. Leike, and R. Lowe, “Training language models to follow instructions with human feedback,” 2022. [Online]. Available: https://arxiv.org/abs/2203.02155 [44] MindSpeed-LLM, https://gitcode.com/Ascend/MindSpeed-LLM, 2026. [45] DeepSeek-AI, “Deepseek-r1: Incentivizing reasoning capability in llmsviareinforcementlearning,”2025.[Online].Available: https://arxiv.org/abs/2501.12948 [46] Z. Shao, P. Wang, Q. Zhu, R. Xu, J. Song, X. Bi, H. Zhang, M. Zhang, Y. K. Li, Y. Wu, and D. Guo, “Deepseekmath: Pushing the limits of mathematical reasoning in open language models,” 2024. [Online]. Available: https://arxiv.org/abs/2402.03300 [47] N. Lambert, “Reinforcement learning from human feedback,” 2025. [Online]. Available: https://arxiv.org/abs/2504.12501 [48] G. Sheng, C. Zhang, Z. Ye, X. Wu, W. Zhang, R. Zhang, Y. Peng, H. Lin, and C. Wu, “Hybridflow: A flexible and efficient rlhf framework,” in Proceedings of the Twentieth European Conference on Computer Systems, ser. EuroSys ’25. ACM, Mar. 2025, p. 1279–1297. [Online]. Available: http://dx.doi.org/10.1145/3689031.3696075 [49] vLLM Ascend, https://github.com/vllm-project/vllm-ascend, 2026. [50] W. U. Ahmad, N. Ludwig, S. Majumdar, and B. Ginsburg, “Open-swe-traces: Advancing dual-mode multilingual distillation forsoftwareengineeringagents,”2026.[Online].Available: https://arxiv.org/abs/2606.16038 [51] DeepSeek-AI, “Deepseek-v4.1-flash: Pushing the limits of kv cache compression,” 2026. [52] GLM-5-Team, “Glm-5: from vibe coding to agentic engineering,” 2026. [Online]. Available: https://arxiv.org/abs/2602.15763 [53] GPT-6 Astra, https://openai.com/index/gpt-6-astra/, 2026.