Kimi-Dev: Agentless Training as Skill Prior for SWE-agents

## Abstract

Abstract Large Language Models (LLMs) are increasingly applied to software engineering (SWE), with SWE-bench as a key benchmark. Solutions are split into SWE-Agent frameworks with multi-turn interactions and workflow-based Agentless methods with single-turn verifiable steps. We argue these paradigms are not mutually exclusive: reasoning-intensive Agentless training induces skill priors, including localization, code edit, and self-reflection that enable efficient and effective SWE-Agent adaptation. In this work, we first curate the Agentless training recipe and present Kimi-Dev, an open-source SWE LLM achieving 60.4% on SWE-bench Verified, the best among workflow approaches. With additional SFT adaptation on 5k publicly-available trajectories, Kimi-Dev powers SWE-Agents to 48.6% pass@1, on par with that of Claude 3.5 Sonnet (241022 version). These results show that structured skill priors from Agentless training can bridge workflow and agentic frameworks for transferable coding agents.

## 1 Introduction

Recent days have witnessed the rapid development of Large Language Models (LLMs) automating Software-Engineering (SWE) tasks (Jimenez et al., 2023; Yang et al., 2024a; Xia et al., 2024; Anthropic, 2024; Pan et al., 2024; Wang et al., 2025a; Wei et al., 2025; Yang et al., 2025a; Kimi et al., 2025; OpenAI, 2025c). Among the benchmarks that track the progress of LLM coding agents in SWE scenarios, SWE-bench (Jimenez et al., 2023) stands out as one of the most representative ones: Given an issue that reports a bug in a real-world GitHub repository, a model is required to produce a patch that fixes the bug, the correctness of which is further judged by whether the corresponding unit tests are passed after its application. The difficulty of the task (as of the date the benchmark was proposed), the existence of the outcome reward with the provided auto-eval harness, as well as the real-world economic value it reflects, have made the SWE-bench a focal point of the field.

Two lines of solutions have emerged for the SWE-bench task. Agent-based solutions like SWE-Agent (Yang et al., 2024a) and OpenHands (Wang et al., 2025a) take an interactionist approach: Instructed with the necessary task description, a predefined set of available tools, as well as the specific problem statement, the agent is required to interact with an executable environment for multiple turns, make change to the source codes, and determine when to stop autonomously. In contrast, workflow-based solutions like Agentless (Xia et al., 2024) pre-define the solving progress as a pipeline, which consists of steps like localization, bug repair, and test composition. Such task decomposition transforms the agentic task into generating correct responses for a chain of single-turn problems with verifiable rewards (Guo et al., 2025; Wei et al., 2025; He et al., 2025).

The two paradigms have been widely viewed as mutually exclusive. On the one hand, SWE-Agents are born with higher potential and better adaptability, thanks to the higher degree of freedom of the multi-turn interaction without the fixed routines. However, it has also proved more difficult to train with such frameworks due to their end-to-end nature (Luo et al., 2025; Cao et al., 2025). On the other hand, Agentless methods offer better modularity and the ease to train with Reinforcement Learning with Verifiable Rewards (RLVR) techniques, but more limited exploration space and flexibility, and difficulty in behavior monitoring as the erroneous patterns appear only in the single-turn long reasoning contents (Pan et al., 2024). However, we challenge the dichotomy from the perspective of training recipe: We argue that Agentless training should not be viewed as the ultimate deliverable, but rather as a way to induce skill priors – atomic capabilities such as the localization of buggy implementations and the update of erroneous code snippets, as well as self-reflection and verification, all of which help scaffold the efficient adaptation of more capable and generalizable SWE-agents.

Guided by this perspective, we introduce Kimi-Dev, an open-source code LLM for SWE tasks. Specifically, we first develop an Agentless training recipe, which includes mid-training, cold-start, reinforcement learning, and test-time self-play. This results in 60.4% accuracy on SWE-bench Verified, the SoTA performance among the workflow-based solutions. Building on this, we show that Agentless training induces skill priors: a minimal SFT cold-start from Kimi-Dev with 5k publicly-available trajectories enables efficient SWE-agent adaptation and reaches 48.6% pass@1 score, similar to that of Claude 3.5 Sonnet (the 20241022 version, Anthropic (2024)). We demonstrate that these induced skills transfer from the non-agentic workflows to the agentic frameworks, and the self-reflection in long Chain-of-Thoughts baked through Agentless training further enable the agentic model to leverage more turns and succeed with a longer horizon. Finally, we also show that the skills from Agentless training generalize beyond SWE-bench Verified to broader benchmarks like SWE-bench-live (Zhang et al., 2025) and SWE-bench Multilingual (Yang et al., 2025c). Together, these results reframe the relationship between Agentless and agentic frameworks: not mutually exclusive, but as complementary stages in building transferable coding LLMs. This shift offers a principled view that training with structural skill priors could scaffold autonomous agentic interaction.

The remainder of this paper is organized as follows. Section [2](https://arxiv.org/html/2509.23045v2#S2) reviews the background of the framework dichotomy and outlines the challenges of training SWE-Agents. Section [3](https://arxiv.org/html/2509.23045v2#S3) presents our Agentless training recipe and the experimental results. Section [4](https://arxiv.org/html/2509.23045v2#S4) demonstrates how these Agentless-induced skill priors enable efficient SWE-Agent adaptation, and evaluates the skill transfer and generalization beyond SWE-bench Verified.

## 2 Background

In this section, we first review the two dominant frameworks for SWE tasks and their dichotomy in Section [2.1](https://arxiv.org/html/2509.23045v2#S2.SS1). We then summarize the progress and challenges of training SWE-Agents in Section [2.2](https://arxiv.org/html/2509.23045v2#S2.SS2). The background introduction sets the stage for reinterpreting Agentless training as skill priors for SWE-Agents, a central theme developed throughout the later sections.

### 2.1 Framework Dichotomy

Two paradigms currently dominate the solutions for automating software engineering tasks. Agentless approaches decompose SWE tasks into modular workflows (Xia et al., 2024; Wei et al., 2025; Ma et al., 2025a; b; Xie et al., 2025). Typical workflows consist of bug localization, bug repair, and test generation. This design provides modularity and stability: each step could be optimized separately as a single-turn problem with verifiable rewards (Wei et al., 2025; He et al., 2025). However, such rigidity comes at the cost of flexibility. When encountering scenarios requiring multiple rounds of incremental updates, the Agentless approaches struggle to adapt.

By contrast, SWE-agents adopt an end-to-end, multi-turn reasoning paradigm (Yang et al., 2024a; Wang et al., 2025a). Rather than following a fixed workflow, they iteratively plan, act, and reflect, resembling how human developers debug complex issues. This design enables greater adaptability, but introduces significant difficulties: trajectories often extend over tens or even hundreds of steps, context windows of the LLMs must span over the entire interaction history, and the model must handle exploration, reasoning, and tool use simultaneously.

The dichotomy between fixed workflows (e.g., Agentless) and agentic frameworks (e.g., SWE-Agent) has shaped much of the community’s perspective. The two paradigms are often regarded as mutually exclusive: one trades off flexibility and performance ceiling for modularity and stability, whereas the other makes the reverse compromise. Our work challenges this dichotomy, as we demonstrate that Agentless training induces skill priors that make further SWE-agent training both more stable and more efficient.

### 2.2 Training SWE-agents

Training SWE-agents relies on acquiring high-quality trajectories through interactions with executable environments. Constructing such large-scale environments and collecting reliable trajectories, however, requires substantial human labor as well as costly calls to frontier models, making data collection slow and resource-demanding (Pan et al., 2024; Badertdinov et al., 2024b). Recent studies also attempt to scale environment construction by synthesizing bugs for the reverse construction of executable runtime (Jain et al., 2025; Yang et al., 2025c).

However, credit assignment across long horizons still remains challenging, as outcome rewards are sparse and often only available when a final patch passes its tests. Reinforcement learning techniques have been proposed, but frequently suffer from instability or collapse when trajectories exceed dozens of steps (Luo et al., 2025; Cao et al., 2025). SWE-agent training is also highly sensitive to initialization: starting from a generic pre-trained model often leads to brittle behaviors, such as failing to use tools effectively or getting stuck in infinite loops of specific action patterns (Pan et al., 2024; Yang et al., 2025c).

These limitations motivate our central hypothesis: instead of training SWE-agents entirely from scratch, one can first induce skill priors through agentless training, enhancing the atomic capabilities like localization, repair, test composition, and self-reflection. These priors lay a foundation that makes subsequent agentic training both more efficient and more generalizable.

## 3 Agentless Training Recipe

Instead of training SWE-agents from scratch, we leverage Agentless training to induce skill priors. Skill priors enhanced by Agentless training include but are not limited to bug localization, patch generation, self-reflection and verification, which lay the foundation for end-to-end agentic interaction. In this section, we elaborate our Agentless training recipe: the duo framework design of BugFixer and TestWriter, mid-training and cold-start, reinforcement learning, and test-time self-play. Sections [3.1](https://arxiv.org/html/2509.23045v2#S3.SS1)–[3.4](https://arxiv.org/html/2509.23045v2#S3.SS4) detail these ingredients, and Section [3.5](https://arxiv.org/html/2509.23045v2#S3.SS5) presents the experimental results for each of them. This training recipe results in Kimi-Dev, an open-source 72B model that achieves 60.4% on SWE-bench Verified, the SoTA performance among the workflow-based solutions.

Figure: Figure 1: Agentless framework for Kimi-Dev: the duo of BugFixer and TestWriter.
Refer to caption: x3.png

### 3.1 Framework: the Duo of Bugfixer and Testwriter

In GitHub issue resolution, we conceptualize the process as the collaboration between two important roles: the BugFixer, who produces patches that correctly address software bugs, and the TestWriter, who creates reproducible unit tests that capture the reported bug. A resolution is considered successful when the BugFixer’s patch passes the tests provided for the issue, while a high-quality test from the TestWriter should fail on the pre-fix version of the code and pass once the fix is applied.

Each role relies on two core skills: (i) file localization, the ability to identify the specific files relevant to the bug or test, and (ii) code edit, the ability to implement the necessary modifications. For BugFixer, effective code edits repair the defective program logic, whereas for TestWriter, they update precise unit test functions that reproduce the issue into the test files. As illustrated in Figure [1](https://arxiv.org/html/2509.23045v2#S3.F1), these two skills constitute the fundamental abilities underlying GitHub issue resolution. Thus, we enhance these skills through the following training recipes, including mid-training, cold-start, and RL.

### 3.2 Mid-Training & Cold Start

To enhance the model’s prior as both a BugFixer and a TestWriter, we perform mid-training with $\sim$150B tokens in high-quality and real-world data. With the Qwen 2.5-72B-Base (Qwen et al., 2024) model as a starting point, we collect millions of GitHub issues and PR commits to form its mid-training dataset, which consists of (i) $\sim$50B tokens in the form of Agentless derived from the natural diff patch, (ii) $\sim$20B tokens of curated PR commit packs, and (iii) $\sim$20B tokens of synthetic data with reasoning and agentic interaction patterns (upsampled by a factor of 4 during training). The data recipe is carefully constructed to enable the model to learn how human developers reason with GitHub issues, implement code fixes, and develop unit tests. We also performed strict data decontamination to exclude any repository from the SWE-bench Verified test set. Mid-training sufficiently enhances the knowledge in the model about practical bug fixes and unit tests, making it a better starting point for later stages. The details of the recipe are covered in Appendix [A](https://arxiv.org/html/2509.23045v2#A1).

To activate the model’s long Chain-of-Thought (CoT) capability, we also construct a cold-start dataset with reasoning trajectories based on the SWE-Gym (Pan et al., 2024) and SWE-bench-extra (Badertdinov et al., 2024a) datasets, generated by the DeepSeek R1 model (Luo et al. (2025), the 20250120 version). In this setup, R1 acts the roles of Bugfixer and Testwriter, producing outputs such as file localization and code edits. Through supervised finetuning as a cold start with this dataset, we enable the model to acquire essential reasoning skills, including problem analysis, method sketching, self-refinement, and exploration of alternative solutions.

### 3.3 Reinforcement Learning

After mid-training and cold-start, the model demonstrates strong performance in localization. Therefore, reinforcement learning (RL) focuses solely on the code edit stage. We construct a training set specifically for this stage, where each prompt is equipped with an executable environment. We further employ multiple localization rollouts from the initial model to generate varied file location predictions, which diversifies the prompts used in code-edit RL.

For the RL algorithm, we adopt the policy optimization method proposed by Kimi k1.5 (Team et al., 2025), which has shown promising results on reasoning tasks in both math and coding. Kimi k1.5 (Team et al., 2025) adopts a simpler policy gradient approach based on the REINFORCE algorithm (Williams, 1992). Similarly to GRPO (Shao et al., 2024), we use the average rewards of multiple rollouts as the baseline to normalize the returns.
When adapting the algorithm in our SWE-bench setting, we highlight the following 3 key desiderata:

- 1.
Outcome-based reward only: We rely solely on the final execution outcome from the environment as the raw reward (0 or 1), without incorporating any format- or process-based signals. For BugFixer, a positive reward is given if the generated patch passes all ground-truth unittests. For TestWriter, a positive reward is assigned when the predicted test raises a failure in the absence of the ground-truth bugfix patch and, once the patch is applied, the failure is resolved.
- 2.
Adaptive prompt selection: Prompts with pass@16 = 0 are initially discarded as they do not contribute to the batch loss, effectively enlarging the usable batch size. A curriculum learning scheme is then applied: once the success rate on the current set exceeds a threshold, previously excluded prompts (with initial pass@16 = 0 but improved under RL) are reintroduced to gradually raise task difficulty.
- 3.
Positive example reinforcement: As performance improvements begin to plateau in later stages of training, we incorporate the positive samples from the recent RL iterations into the training batch of the current iteration. This approach reinforces the model’s reliance on successful patterns, thereby accelerating convergence in the final phase.

Robust sandbox infrastructure. We construct the docker environment with Kubernetes (Burns et al., 2016), which provides a secure and scalable sandbox infrastructure and efficient training and rollouts. The infra supports over 10,000 concurrent instances with robust performance, making it ideal for competitive programming and software engineering tasks (see Appendix [D](https://arxiv.org/html/2509.23045v2#A4) for details).

### 3.4 Test-Time Self-Play

After RL, the model masters the roles of both a BugFixer and a TestWriter.
During test time, it adopts a self-play mechanism to coordinate its bug-fixing and test-writing abilities.

Following Agentless (Xia et al., 2024), we leverage the model to generate 40 candidate patches and 40 tests for each instance. Each patch generation involves independent runs of the localization and code edit from BugFixer, where the first run uses greedy decoding (temperature 0), and the remaining 39 use temperature 1 to ensure diversity. Similarly, 40 tests are generated independently from TestWriter. For the test patch candidates, to guarantee their validity, we first filter out those failing to raise a failure in the original repo without applying any BugFixer patch.

Denote the rest TestWriter patches as set $\mathcal{T}$, and the BugFixer patches as set $\mathcal{B}$. For each $b_{i}\in\mathcal{B}$ and $t_{j}\in\mathcal{T}$, we execute the test suite over the test file modified by $t_{j}$ for twice: first without $b_{i}$, and then with $b_{i}$ applied. From the execution log for the first run, we get the count of the failed and the passed tests from $t_{j}$, denoted as ${\rm F}(j)$ and ${\rm P}(j)$. Comparing the execution logs for the two test suite runs, we get the count of the fail-to-pass and the pass-to-pass tests, denoted as ${\rm FP}(i,j)$ and ${\rm PP}(i,j)$, respectively. We then calculate the score for each $b_{i}$ with

$$ $S_{i}=\frac{\sum_{j}{\rm FP}(i,j)}{\sum_{j}{\rm F}(j)}+\frac{\sum_{j}{\rm PP}(i,j)}{\sum_{j}{\rm P}(j)},$ (1) $$

where the first part reflects the performance of $b_{i}$ under reproduction tests, and the second part could be viewed as the characterization of $b_{i}$ under regression tests (Xia et al., 2024). We select the BugFixer patch $b_{i}$ with the highest $S_{i}$ score as the ultimate answer.

**Table 1: Performance comparison for models on SWE-bench Verified under Agentless-like frameworks. All the performances are obtained under the standard 40 patch, 40 test setting (Xia et al., 2024), except that Llama3-SWE-RL uses 500 patches and 30 tests.**
| Model | #Params | Resolve Rate (%) |
| --- | --- | --- |
| Llama3-SWE-RL (Wei et al., 2025) | 70B | 41.0 |
| Seed1.5-Thinking (Seed et al., 2025) | 200B | 47.0 |
| OpenAI-o1 (OpenAI, 2024) | - | 48.9 |
| DeepSeek-R1-0120 (Guo et al., 2025) | 671B | 49.2 |
| OpenAI-o3-mini-high (OpenAI, 2025a) | - | 49.3 |
| Claude 3.5 Sonnet (241022) (Anthropic, 2024) | - | 50.8 |
| MiniMax-M1 (Chen et al., 2025a) | 456B | 56.0 |
| DeepSeek-R1-0528 (Guo et al., 2025) | 671B | 57.6 |
| SWE-SWISS (He et al., 2025) | 32B | 58.2 |
| Kimi-Dev (Ours) | 72B | 60.4 |

### 3.5 Experiments

#### 3.5.1 Main Results

We evaluate our approach on SWE-bench Verified (Jimenez et al., 2023), which includes 500 GitHub issues guaranteed to be solved by human programmers. Table [1](https://arxiv.org/html/2509.23045v2#S3.T1) shows the overall results. Unlike SWE-RL (Wei et al., 2025), which relies on text-based similarity to the ground-truth patch, we use execution results as the reward signal, reducing shortcuts and improving solution quality. Unlike most Agentless approaches (Xia et al., 2024; Guo et al., 2025; He et al., 2025), which place a single-file reproduction test at the root directory of the repository, we leverage the two-stage TestWriter to better capture repository context and align with human standard workflows (OpenAI, 2025). Kimi-Dev model achieves the state-of-the-art performance among open-source models, resolving 60.4% of the issues in SWE-bench Verified.

#### 3.5.2 Mid-Training

Figure: Figure 2: The performance on SWE-bench Verified of the finetuned Qwen 2.5-72B-Base model as the mid-training token budget increases.
Refer to caption: figs/sec3_mid_training/mid-train_perf.png

In this section, we evaluate the relationship between the amount of data used during mid-training and model performance. Specifically, we finetuned Qwen 2.5-72B-Base with the subset of mid-training data of 50B, 100B, and approximately 150B tokens, and then lightly activated these mid-trained models using the same set of 2,000 Bugfixer input-output pairs for SFT cold start. We only report BugFixer pass@1 here for simplicity of evaluation.
Figure [2](https://arxiv.org/html/2509.23045v2#S3.F2) shows that increasing the number of tokens in mid-training consistently improves model performance, highlighting the effectiveness of this stage.

#### 3.5.3 Reinforcement Learning

Figure: (a) 72B Joint RL, BugFixer
Refer to caption: figs/sec3_rl_scaling/quick_plot_twin_bf_final.png

##### Experimental setup

We set the training step per RL iteration as 5 and sample 10 rollouts for each of the 1,024 problems from the union of SWE-gym (Pan et al., 2024) and SWE-bench-extra (Badertdinov et al., 2024b). We dynamically adjust the prompt set every 20 iterations to gradually increase task difficulty. We fix the maximum training context length as 64k tokens, since the prompt input contains the contents of the entire files localized by the initial model in advance.

##### Results

Figure [3](https://arxiv.org/html/2509.23045v2#S3.F3) shows the performance and response length curves on the test set during RL training. The pass rate and the reproduced rate are calculated from pass@1 and temperature=1. Specifically, we observe that both model performance and response length steadily increase, reflecting the expected benefits of RL scaling. Similar RL scaling curves are also observed in our ablation experiments run on Qwen2.5-14B-Instruct models, proving the effectiveness of the RL training recipe across models of different sizes. The experimental details, as well as the ablation studies on positive example reinforcement in Section [3.3](https://arxiv.org/html/2509.23045v2#S3.SS3), are listed in Appendix [C.2](https://arxiv.org/html/2509.23045v2#A3.SS2)).
The lengthy outputs consist of in-depth problem analysis and self-reflection patterns, similar to those in the math and code reasoning tasks (Team et al., 2025; Guo et al., 2025). We have also observed that for TestWriter, occasional false-positive examples take place during RL training due to the lack of reproduction coverage. We leave the case studies in Appendix [E](https://arxiv.org/html/2509.23045v2#A5) and further improvement for future work.

#### 3.5.4 Test-time Self-Play

Following Section [3.4](https://arxiv.org/html/2509.23045v2#S3.SS4), we evaluate how the final performance on the SWE-bench Verified scales with the number of patches and tests generated. The temperature is fixed at 0 for the initial rollout and set to 1.0 for the subsequent 39 rollouts. As shown on the left of Figure [4](https://arxiv.org/html/2509.23045v2#S3.F4), performance improves from 48.0% to 60.4% as the number of patch test pairs increases from 1$\times$1 to 40$\times$40, and consistently outperforms the results obtained from the majority vote of BugFixer patches.

Figure: Figure 4: Test-time self-play on SWE-bench Verified. Performance improves with more generated patches and tests. Left: Execution-based self-play consistently surpasses BugFixer majority voting. Right: Self-play performances remain below pass@N where the ground-truth test patch is used, suggesting the room exists for TestWriter to improve.
Refer to caption: figs/sec3_sp_scaling/selfplay_figure_v2.png

Specifically, the self-play result obtained from 3 patches and 3 tests for each instance has already surpassed the performance with majority voting from 40 BugFixer patches. This demonstrates the effectiveness of additional information from test-time execution. The room for improvement of TestWriter, though, still exists for more powerful self-play: Shown on Figure [4](https://arxiv.org/html/2509.23045v2#S3.F4), self-play performances remain below pass@N, where ground-truth test cases serve as the criterion for issue resolution. This finding aligns with Anthropic (2024), which introduced a final edge-case checking phase to generate a more diverse set of test cases, thereby strengthening the role of the “TestWriter” in their SWE-Agent framework. We also report preliminary observations of a potential parallel scaling phenomenon, which requires no additional training and may enable scalable performance improvements. The details of the phenomenon and analyses are covered in Appendix [F](https://arxiv.org/html/2509.23045v2#A6).

## 4 Initializing SWE-Agents from Agentless Training

End-to-end multi-turn frameworks, such as SWE-Agent (Yang et al., 2024a; Anthropic, 2024) and OpenHands (Wang et al., 2025a), enable agents to leverage tools and interact with environments. Specifically, the system prompt employed in the SWE-Agent framework (Anthropic, 2024) outlines a five-stage workflow: (i) repo exploration, (ii) error reproduction via a test script, (iii) code edit for bug repair, (iv) test re-execution for validation, and (v) edge-case generation and checks. Unlike Agentless, the SWE-Agent framework doesn’t enforce a strict stage-wise workflow; the agent can reflect, transition, and redo freely until it deems the task complete and submits.

The performance potential is therefore higher without a fixed routine; However, the training for SWE-Agent is more challenging because of the sparsity of the outcome reward for long-horizon credit assignment. Meanwhile, our Kimi-Dev model has undergone Agentless training, with its skills of localization and code edit for BugFixer and TestWriter strengthened elaborately. In this section, we investigate whether it can serve as an effective prior for multi-turn SWE-Agent scenarios.

**Table 2: Single-attempt performance of different models on SWE-bench Verified under end-to-end agentic frameworks, categorized by proprietary or open-weight models, and size over or under 100B. “Internal” denotes results achieved with their in-house agentic frameworks.**
| Model | System | #Params | Pass Rate (%) |
| --- | --- | --- | --- |
| Proprietary |  |  |  |
| Gemini 2.5 Pro (Comanici et al., 2025) | Internal | - | 60.3 |
| OpenAI-o3 (OpenAI, 2025) | Internal | - | 69.1 |
| GPT-5  (OpenAI, 2025c) | Internal | - | 74.9 |
| Claude 3.5 Sonnet (241022) (Anthropic, 2024) | SWE-Agent | - | 49.0 |
| Claude 3.7 Sonnet (Anthropic, 2025a) | SWE-Agent | - | 62.3 |
| Claude 4.0 Sonnet (Anthropic, 2025b) | SWE-Agent | - | 72.7 |
| Open Weight, $\geq$ 100B |  |  |  |
| gpt-oss-120b (High) (OpenAI, 2025b) | Internal | 120B | 62.4 |
| DeepSeek-v3.1 (Guo et al., 2025) | Internal | 671B | 66.0 |
| Kimi-K2-0905 (Kimi et al., 2025) | SWE-Agent | 1T | 69.2 |
| Qwen3-Coder (Yang et al., 2025a) | OpenHands | 480B | 69.6 |
| Open Weight, $<$ 100B |  |  |  |
| Openhands-LM (Wang et al., 2025b) | OpenHands | 32B | 37.2 |
| Skywork-SWE (Zeng et al., 2025) | OpenHands | 32B | 38.0 |
| SWE-agent-LM (Yang et al., 2025b) | SWE-Agent | 32B | 40.2 |
| DeepSWE (Luo et al., 2025) | OpenHands | 32B | 42.2 |
| Devstral-Small-2507 (AI & AI, 2025) | OpenHands | 24B | 53.6 |
| gpt-oss-20b (High) (OpenAI, 2025b) | Internal | 20B | 60.7 |
| Kimi-Dev (SFTed) | SWE-Agent | 72B | 48.6 |

### 4.1 Performance after SWE-Agent Fine-tuning

We use the publicly available SWE-Agent trajectories to finetune Kimi-Dev. The finetuning dataset we used is released by SWE-smith (Yang et al., 2025b), consisting of 5,016 SWE-Agent trajectories collected with Claude 3.7 Sonnet (Anthropic, 2025a) in the synthetic environments. We perform supervised fine-tuning over Kimi-Dev, setting the maximum context length as 64K tokens during training, and allowing up to 128K tokens and 100 turns during inference.

As shown in Table [2](https://arxiv.org/html/2509.23045v2#S4.T2), without collecting more trajectory data over realistic environments, or conducting additional multi-turn agentic RL, our finetuned model achieves a pass@1 score of 48.6% on SWE-bench Verified under the agentic framework setup, without additional test-time scaling. Using the same SFT data, our finetuned Kimi-Dev model outperforms the SWE-agent-LM (Yang et al., 2025c), with the performance comparable to that of Claude 3.5 Sonnet (49% by the 241022 version). The pass@10 of our SWE-Agent adapted model is 74.0% and surpasses the pass@30 of our model under Agentless (73.8%), proving the higher potential for the SWE-Agent framework.

### 4.2 Skill Transfer and Generalization

The results shown in Section [4.1](https://arxiv.org/html/2509.23045v2#S4.SS1) demonstrate that Kimi-Dev, a model with extensive Agentless training, could be adapted to end-to-end SWE-Agents with lightweight supervised finetuning. As the Agentless training recipe consists of mid-training, cold-start (SFT) and RL, we explore the contribution of each part in the recipe to the SWE-Agent capability after adaptation.

To figure this out, we perform SWE-Agent SFT on the original Qwen2.5-72B (Base), the mid-trained model (MT), the model then activated with Agentless-formatted long CoT data (SFT), and the (Kimi-Dev) model after finishing RL training (RL). As we are treating the four models as the prior for SWE-Agents(^1^11We slightly abuse the term “prior” to refer to a model to be finetuned with SWE-Agent trajectories in the following analysis.), and a good prior always demonstrates the ability of fast adaptation with a few shots (Finn et al., 2017; Brown et al., 2020), we also sweep the amount of SWE-Agent SFT data to measure the efficiency of each prior in SWE-Agent adaptation.

Specifically, we randomly shuffle the 5,016 SWE-Agent trajectories and construct nested subsets of sizes 100, 200, 500, 1,000, and 2,000, where each smaller subset is contained within the larger ones. In addition, we prepend two extreme baselines: (i) zero-shot, where the prior model is directly evaluated under the SWE-Agent framework without finetuning, and (ii) one-step gradient descent, where the model is updated with a single gradient step using the 100-trajectory subset. This yields a range of SFT token budgets spanning {0, $2^{21}$, $2^{23}$, $2^{24}$, $1.1\times 2^{25}$, $1.1\times 2^{26}$, $1.1\times 2^{27}$, $1.5\times 2^{28}$}. After these lightweight SFT experiments, we evaluate performance in terms of pass@{1,2,3} under the SWE-Agent framework, with evaluations for pass@1 conducted at temperature 0, and those for pass@2 and pass@3 at temperature 1.0.

Figure [5](https://arxiv.org/html/2509.23045v2#S4.F5) presents the SWE-Agent performances of each prior (Base, MT, SFT, RL) after being fine-tuned with different amounts of agentic trajectories. We have the following observations:

- 1.
The RL prior outperforms all the other models in nearly all the SWE-Agent SFT settings. This demonstrates that the Agentless training recipe indeed strengthens the prior in terms of SWE-Agent adaptation. For example, To achieve the top pass@1 performance of the Base prior, the RL prior needs only $2^{23}$ SWE-Agent SFT tokens, whereas the Base prior consumes $1.5\times 2^{28}$ tokens.
- 2.
The MT prior is lagged behind the SFT and the RL ones in extremely data-scarce settings (zero-shot (0) and one-step gradient descent ($2^{21}$) ), but quickly becomes on par with them after 200 trajectories ($2^{24}$) are available for finetuning. This indicates that adaptation efficiency remains comparable after the prior is strengthened through Agentless mid-training.
- 3.
The performance of the SFT prior is mostly similar to the RL one except for two cases: (i) The SFT prior outperforms the RL one under the zero-shot setting. This is reasonable, as the RL prior might overfit to the Agentless input-output format, while the SFT prior suffers less from this. (ii) The SFT prior exhibits a significant degradation with 200 SWE-Agent trajectories ($2^{24}$). A potential reason could be that the 200 trajectories collapse onto a single data mode, leading the SFT prior to overfit through memorization (Chu et al., 2025); the RL prior instead embeds stronger transferable skills and thus generalizes better.

Figure: Figure 5: Comparing the quality of the raw Base, the Agentless mid-trained (MT), the Agentless mid-trained with reasoning-intensive cold-start (SFT), and the Kimi-Dev model after RL as the prior for SWE-Agent adaptation. The tokens of the SWE-Agent SFT trajectories are swept over different scales, and the SWE-Agent performances are reported up to pass@3 on SWE-bench Verified.
Refer to caption: figs/sec4_main/v-sweeping-new-FINAL.png

Figure: Figure 6: Left: Performance of the four priors under turn limits after SWE-Agent adaptation. Right: The characterization of the BugFixer and the reflection skills for each prior by counting the resolved cases of the 3 runs at Stage-3 cutoff moment, and comparing those with the final success cases.
Refer to caption: figs/sec4_long_cot_to_multi_turn/hist_steps_6x4.png

##### From long CoT to extended multi-turn interactions.

We hypothesize that reflective behaviors cultivated through long chain-of-thought reasoning may transfer to settings requiring extended multi-turn interactions. To examine this, we evaluate the four priors (Base, MT, SFT, and RL) by finetuning on the 5,016 trajectories and test on SWE-bench Verified, under varying turn limits with pass@3 as the metric (Figure [6](https://arxiv.org/html/2509.23045v2#S4.F6), left). The distinct interaction-length profiles show supportive evidence: the RL prior, after finetuning, continues to make progress beyond 70 turns, while the SFT, mid-trained, and raw models show diminishing returns around 70, 60, and 50 turns, respectively.

We further evaluate the efficacy of the Agentless skill priors (BugFixer and reflection) in the SWE-Agent adapted model. For BugFixer, given that the SWE-Agent may autonomously reflect between the five stages, we examine the moment in each trajectory when the bug fix of the third stage is initially completed, and the test rerun of the fourth stage has not yet been entered. Heuristically, when the SWE-Agent just completes the third stage, it has not yet obtained the execution feedback from the fourth stage, and thus has not further reflected based on the execution information or refined the bug fix. We therefore calculate the success rate of direct submission at this cutoff moment, which reflects the capability of the BugFixer skill. Regarding reflection, we further compare the performance at the cutoff point with the performance after full completion for each problem. The increment in the number of successful problems is used to reflect the capability of the reflection skill.

We use kimi-k2-0711-preview (Kimi et al., 2025) to annotate the SWE-Agent trajectories, identifying the stage to which each turn belongs. Figure [6](https://arxiv.org/html/2509.23045v2#S4.F6) (right) demonstrates that both skills are strengthened through each stage of the Agentless training recipe: For the BugFixer skill, the cutoff performance at Stage-3 within the SWE-Agent interaction trajectories of the four adapted models shows consistent improvement, ranging from 484 cases resolved by the Base prior to 605 cases by the RL prior, as measured by the number of successful resolutions within three passes. For the reflection skill, examining the performance gains from Stage-3 to the end of the trajectories reveals a similar trend, with improvements increasing from +94 under the Base prior to +113 under the RL prior. Taken together, the adapted model from the RL prior achieves the strongest overall performance across both skills. It should be noted that our analysis of the reflection skill remains coarse-grained, since the measured performance gains between the two checkpoints capture not only agentic reflection and redo behaviors, but also the intermediate test-writing process performed by the SWE-Agent. A more fine-grained evaluation that isolates the TestWriter skill prior is left for future work. The prompt for SWE-Agent stage annotation, extended qualitative studies, as well as additional discussions for skill transfer and generalization, are covered in Appendix [G](https://arxiv.org/html/2509.23045v2#A7).

## 5 Conclusion and Future Work

In this work, we reframed Agentless and agentic paradigms for automated software engineering as complementary rather than competing. By introducing Kimi-Dev, we demonstrated that structured Agentless training can induce transferable skill priors, including bug localization, code repair, and self-reflection. As a result, Kimi-Dev not only achieves SoTA results on SWE-bench Verified among the workflow-based approaches, but enables efficient SWE-Agent adaptation as well. These findings establish a novel path toward building more generalizable coding agents through staged training. Looking ahead, we plan to extend our evaluation to more realistic scenarios of human-agent-environment interaction (Yang et al., 2024c; Tang et al., 2025), explore finer-grained reward signals for RL training in SWE tasks, and test the generality of training with structured workflow priors in domains beyond software engineering.

## Acknowledgements

We thank Yuzhi Wang, Xinyu Zhou, Guokun Lai, Yulun Du, Fang Li, Hao Ding, Dehao Zhang, Dikang Du, and Jiacheng You for their valuable suggestions. We also appreciate the members of the infrastructure team at Moonshot AI for their timely support during the project.

## Ethics and Reproducibility Statements

This work obeys the Code of Ethics required by the ICLR conference. The study does not involve human subjects or animal experimentation. The personally identifiable information from raw data is excluded for privacy consideration (see the mid-training data recipe detailed in Appendix [A](https://arxiv.org/html/2509.23045v2#A1)). Beyond the scope of this work, we strongly advocate for the community to advance systematic research on agent safety, thereby ensuring responsible progress in this area.

For all of the experiments, we have covered the detailed setups and discussions in the appendices: mid-training for Agentless in Appendix [A](https://arxiv.org/html/2509.23045v2#A1), details of the used dockers in Appendix [B](https://arxiv.org/html/2509.23045v2#A2), Agentless RL in Appendix [C](https://arxiv.org/html/2509.23045v2#A3), agent infrastructure in Appendix [D](https://arxiv.org/html/2509.23045v2#A4), case studies under Agentless in Appendix [E](https://arxiv.org/html/2509.23045v2#A5), preliminary findings about emergent test-time parallel scaling in Appendix [F](https://arxiv.org/html/2509.23045v2#A6), and extended analysis for SWE-Agents in Appendix [G](https://arxiv.org/html/2509.23045v2#A7).

## References

- AI & AI (2025)
Mistral AI and All Hands AI.
Devstral-small-2507.
[https://mistral.ai/news/devstral-2507](https://mistral.ai/news/devstral-2507), July 2025.
- Anthropic (2024)
Anthropic.
Raising the bar on swe-bench verified with claude 3.5 sonnet.
Online; AI model, Oct 2024.
URL [https://www.anthropic.com/engineering/swe-bench-sonnet](https://www.anthropic.com/engineering/swe-bench-sonnet).
- Anthropic (2025a)
Anthropic.
Claude 3.7 sonnet: Hybrid reasoning model.
[https://www.anthropic.com/news/claude-3-7-sonnet](https://www.anthropic.com/news/claude-3-7-sonnet), February 2025a.
- Anthropic (2025b)
Anthropic.
Claude sonnet 4.
[https://www.anthropic.com/news/claude-4](https://www.anthropic.com/news/claude-4), May 2025b.
- Badertdinov et al. (2024a)
Ibragim Badertdinov, Maria Trofimova, Yuri Anapolskiy, Sergey Abramov, Karina Zainullina, Alexander Golubev, Sergey Polezhaev, Daria Litvintseva, Simon Karasik, Filipp Fisin, et al.
Scaling data collection for training software engineering agents.
*Nebius blog*, 2024a.
- Badertdinov et al. (2024b)
Ibragim Badertdinov, Maria Trofimova, Yury Anapolskiy, Sergey Abramov, Karina Zainullina, Alexander Golubev, Sergey Polezhaev, Daria Litvintseva, Simon Karasik, Filipp Fisin, Sergey Skvortsov, Maxim Nekrashevich, Anton Shevtsov, and Boris Yangel.
Scaling data collection for training software engineering agents.
*Nebius blog*, 2024b.
- Badertdinov et al. (2025)
Ibragim Badertdinov, Alexander Golubev, Maksim Nekrashevich, Anton Shevtsov, Simon Karasik, Andrei Andriushchenko, Maria Trofimova, Daria Litvintseva, and Boris Yangel.
Swe-rebench: An automated pipeline for task collection and decontaminated evaluation of software engineering agents, 2025.
URL [https://arxiv.org/abs/2505.20411](https://arxiv.org/abs/2505.20411).
- Brown et al. (2020)
Tom B. Brown, Benjamin Mann, Nick Ryder, Melanie Subbiah, Jared Kaplan, Prafulla Dhariwal, Arvind Neelakantan, Pranav Shyam, Girish Sastry, Amanda Askell, Sandhini Agarwal, Ariel Herbert-Voss, Gretchen Krueger, Tom Henighan, Rewon Child, Aditya Ramesh, Daniel M. Ziegler, Jeffrey Wu, Clemens Winter, Christopher Hesse, Mark Chen, Eric Sigler, Mateusz Litwin, Scott Gray, Benjamin Chess, Jack Clark, Christopher Berner, Sam McCandlish, Alec Radford, Ilya Sutskever, and Dario Amodei.
Language models are few-shot learners.
*Advances in Neural Information Processing Systems*, 33:1877–1901, 2020.
URL [https://arxiv.org/abs/2005.14165](https://arxiv.org/abs/2005.14165).
- Burns et al. (2016)
Brendan Burns, Brian Grant, David Oppenheimer, Eric Brewer, and John Wilkes.
Borg, Omega, and Kubernetes.
In *Proceedings of the 10th USENIX Symposium on Operating Systems Design and Implementation (OSDI ’16)*, pp. 285–301, 2016.
- Cao et al. (2025)
Shiyi Cao, Sumanth Hegde, Dacheng Li, Tyler Griggs, Shu Liu, Eric Tang, Jiayi Pan, Xingyao Wang, Akshay Malik, Graham Neubig, Kourosh Hakhamaneshi, Richard Liaw, Philipp Moritz, Matei Zaharia, Joseph E. Gonzalez, and Ion Stoica.
Skyrl-v0: Train real-world long-horizon agents via reinforcement learning, 2025.
- Chen et al. (2025a)
Aili Chen, Aonian Li, Bangwei Gong, Binyang Jiang, Bo Fei, Bo Yang, Boji Shan, Changqing Yu, Chao Wang, Cheng Zhu, et al.
Minimax-m1: Scaling test-time compute efficiently with lightning attention.
*arXiv preprint arXiv:2506.13585*, 2025a.
- Chen et al. (2025b)
Mouxiang Chen, Binyuan Hui, Zeyu Cui, Jiaxi Yang, Dayiheng Liu, Jianling Sun, Junyang Lin, and Zhongxin Liu.
Parallel scaling law for language models.
*arXiv preprint arXiv:2505.10475*, 2025b.
- Chu et al. (2025)
Tianzhe Chu, Yuexiang Zhai, Jihan Yang, Shengbang Tong, Saining Xie, Dale Schuurmans, Quoc V Le, Sergey Levine, and Yi Ma.
SFT memorizes, RL generalizes: A comparative study of foundation model post-training.
In *Forty-second International Conference on Machine Learning*, 2025.
URL [https://openreview.net/forum?id=dYur3yabMj](https://openreview.net/forum?id=dYur3yabMj).
- Comanici et al. (2025)
Gheorghe Comanici, Eric Bieber, Mike Schaekermann, Ice Pasupat, Noveen Sachdeva, Inderjit Dhillon, Marcel Blistein, Ori Ram, Dan Zhang, Evan Rosen, et al.
Gemini 2.5: Pushing the frontier with advanced reasoning, multimodality, long context, and next generation agentic capabilities.
*arXiv preprint arXiv:2507.06261*, 2025.
- Finn et al. (2017)
Chelsea Finn, Pieter Abbeel, and Sergey Levine.
Model-agnostic meta-learning for fast adaptation of deep networks.
In *International conference on machine learning*, pp. 1126–1135. PMLR, 2017.
- Grattafiori et al. (2024)
Aaron Grattafiori, Abhimanyu Dubey, Abhinav Jauhri, Abhinav Pandey, Abhishek Kadian, Ahmad Al-Dahle, Aiesha Letman, Akhil Mathur, Alan Schelten, Alex Vaughan, et al.
The llama 3 herd of models.
*arXiv preprint arXiv:2407.21783*, 2024.
- Gu et al. (2025)
Xinran Gu, Kaifeng Lyu, Jiazheng Li, and Jingzhao Zhang.
Data mixing can induce phase transitions in knowledge acquisition.
*arXiv preprint arXiv:2505.18091*, 2025.
- Guo et al. (2025)
Daya Guo, Dejian Yang, Haowei Zhang, Junxiao Song, Ruoyu Zhang, Runxin Xu, Qihao Zhu, Shirong Ma, Peiyi Wang, Xiao Bi, et al.
Deepseek-r1: Incentivizing reasoning capability in llms via reinforcement learning.
*arXiv preprint arXiv:2501.12948*, 2025.
- He et al. (2025)
Zhenyu He, Qingping Yang, Wei Sheng, Xiaojian Zhong, Kechi Zhang, Chenxin An, Wenlei Shi, Tianle Cai, Di He, Jiaze Chen, Jingjing Xu, and Mingxuan Wang.
Swe-swiss: A multi-task fine-tuning and rl recipe for high-performance issue resolution.
[Notion page](https://www.notion.so/SWE-Swiss-A-Multi-Task-Fine-Tuning-and-RL-Recipe-for-High-Performance-Issue-Resolution-21e174dedd4880ea829ed4c861c44f88), 2025.
- Jain et al. (2025)
Naman Jain, Jaskirat Singh, Manish Shetty, Liang Zheng, Koushik Sen, and Ion Stoica.
R2e-gym: Procedural environments and hybrid verifiers for scaling open-weights swe agents.
*arXiv preprint arXiv:2504.07164*, 2025.
- Jimenez et al. (2023)
Carlos E Jimenez, John Yang, Alexander Wettig, Shunyu Yao, Kexin Pei, Ofir Press, and Karthik Narasimhan.
Swe-bench: Can language models resolve real-world github issues?
*arXiv preprint arXiv:2310.06770*, 2023.
- Kimi et al. (2025)
Team Kimi, Yifan Bai, Yiping Bao, Guanduo Chen, Jiahao Chen, Ningxin Chen, Ruijue Chen, Yanru Chen, Yuankun Chen, Yutian Chen, et al.
Kimi k2: Open agentic intelligence.
*arXiv preprint arXiv:2507.20534*, 2025.
- Luo et al. (2025)
Michael Luo, Naman Jain, Jaskirat Singh, Sijun Tan, Ameen Patel, Qingyang Wu, Alpay Ariyak, Colin Cai, Shang Zhu Tarun Venkat, Ben Athiwaratkun, Manan Roongta, Ce Zhang, Li Erran Li, Raluca Ada Popa, Koushik Sen, and Ion Stoica.
DeepSWE: Training a State-of-the-Art Coding Agent from Scratch by Scaling RL.
[Notion page](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.
- Ma et al. (2025a)
Yingwei Ma, Rongyu Cao, Yongchang Cao, Yue Zhang, Jue Chen, Yibo Liu, Yuchen Liu, Binhua Li, Fei Huang, and Yongbin Li.
Swe-gpt: A process-centric language model for automated software improvement.
*Proc. ACM Softw. Eng.*, 2(ISSTA), June 2025a.
doi: 10.1145/3728981.
URL [https://doi.org/10.1145/3728981](https://doi.org/10.1145/3728981).
- Ma et al. (2025b)
Yingwei Ma, Qingping Yang, Rongyu Cao, Binhua Li, Fei Huang, and Yongbin Li.
Alibaba lingmaagent: Improving automated issue resolution via comprehensive repository exploration.
In *Proceedings of the 33rd ACM International Conference on the Foundations of Software Engineering*, pp. 238–249, 2025b.
- OpenAI (2024)
OpenAI.
Openai o1 system card.
Technical report, OpenAI, 2024.
URL [https://arxiv.org/abs/2412.16720](https://arxiv.org/abs/2412.16720).
Includes o1 and o1-mini models, safety and evaluation work.
- OpenAI (2025)
OpenAI.
Introducing codex.
[https://openai.com/index/introducing-codex/](https://openai.com/index/introducing-codex/), May 2025.
- OpenAI (2025)
OpenAI.
Openai o3 and openai o4-mini system card.
Technical report, OpenAI, Apr 2025.
URL [https://cdn.openai.com/pdf/2221c875-02dc-4789-800b-e7758f3722c1/o3-and-o4-mini-system-card.pdf](https://cdn.openai.com/pdf/2221c875-02dc-4789-800b-e7758f3722c1/o3-and-o4-mini-system-card.pdf).
- OpenAI (2025a)
OpenAI.
Openai o3-mini system card.
Technical report / system card, OpenAI, 2025a.
URL [https://cdn.openai.com/o3-mini-system-card-feb10.pdf](https://cdn.openai.com/o3-mini-system-card-feb10.pdf).
Description of o3-mini model, its safety evaluations and reasoning benchmarks.
- OpenAI (2025b)
OpenAI.
gpt-oss-120b & gpt-oss-20b model card, 2025b.
URL [https://arxiv.org/abs/2508.10925](https://arxiv.org/abs/2508.10925).
- OpenAI (2025c)
OpenAI.
Gpt-5 system card.
OpenAI website, Aug 2025c.
URL [https://cdn.openai.com/gpt-5-system-card.pdf](https://cdn.openai.com/gpt-5-system-card.pdf).
- Pan et al. (2024)
Jiayi Pan, Xingyao Wang, Graham Neubig, Navdeep Jaitly, Heng Ji, Alane Suhr, and Yizhe Zhang.
Training software engineering agents and verifiers with swe-gym.
*arXiv preprint arXiv:2412.21139*, 2024.
- Pan et al. (2025)
Jiayi Pan, Xiuyu Li, Long Lian, Charlie Victor Snell, Yifei Zhou, Adam Yala, Trevor Darrell, Kurt Keutzer, and Alane Suhr.
Learning adaptive parallel reasoning with language models.
In *Second Conference on Language Modeling*, 2025.
URL [https://openreview.net/forum?id=YgwQ7sXPXU](https://openreview.net/forum?id=YgwQ7sXPXU).
- Qwen et al. (2024)
Qwen, :, An Yang, Baosong Yang, Beichen Zhang, Binyuan Hui, Bo Zheng, Bowen Yu, Chengyuan Li, Dayiheng Liu, Fei Huang, Haoran Wei, Huan Lin, Jian Yang, Jianhong Tu, Jianwei Zhang, Jianxin Yang, Jiaxi Yang, Jingren Zhou, Junyang Lin, Kai Dang, Keming Lu, Keqin Bao, Kexin Yang, Le Yu, Mei Li, Mingfeng Xue, Pei Zhang, Qin Zhu, Rui Men, Runji Lin, Tianhao Li, Tianyi Tang, Tingyu Xia, Xingzhang Ren, Xuancheng Ren, Yang Fan, Yang Su, Yichang Zhang, Yu Wan, Yuqiong Liu, Zeyu Cui, Zhenru Zhang, and Zihan Qiu.
Qwen2.5 technical report, 2024.
URL [https://arxiv.org/abs/2412.15115](https://arxiv.org/abs/2412.15115).
- Seed et al. (2025)
ByteDance Seed, Jiaze Chen, Tiantian Fan, Xin Liu, Lingjun Liu, Zhiqi Lin, Mingxuan Wang, Chengyi Wang, Xiangpeng Wei, Wenyuan Xu, et al.
Seed1. 5-thinking: Advancing superb reasoning models with reinforcement learning.
*arXiv preprint arXiv:2504.13914*, 2025.
- Shao et al. (2024)
Zhihong Shao, Peiyi Wang, Qihao Zhu, Runxin Xu, Junxiao Song, Xiao Bi, Haowei Zhang, Mingchuan Zhang, YK Li, Yang Wu, et al.
Deepseekmath: Pushing the limits of mathematical reasoning in open language models.
*arXiv preprint arXiv:2402.03300*, 2024.
- Tang et al. (2025)
Xiangru Tang, Qiao Jin, Kunlun Zhu, Tongxin Yuan, Yichi Zhang, Wangchunshu Zhou, Meng Qu, Yilun Zhao, Jian Tang, Zhuosheng Zhang, et al.
Risks of AI scientists: prioritizing safeguarding over autonomy.
*Nature Communications*, 16(1):8317, 2025.
- Team et al. (2025)
Kimi Team, Angang Du, Bofei Gao, Bowei Xing, Changjiu Jiang, Cheng Chen, Cheng Li, Chenjun Xiao, Chenzhuang Du, Chonghua Liao, et al.
Kimi k1. 5: Scaling reinforcement learning with llms.
*arXiv preprint arXiv:2501.12599*, 2025.
- Wang et al. (2025a)
Xingyao Wang, Boxuan Li, Yufan Song, Frank F. Xu, Xiangru Tang, Mingchen Zhuge, Jiayi Pan, Yueqi Song, Bowen Li, Jaskirat Singh, Hoang H. Tran, Fuqiang Li, Ren Ma, Mingzhang Zheng, Bill Qian, Yanjun Shao, Niklas Muennighoff, Yizhe Zhang, Binyuan Hui, Junyang Lin, Robert Brennan, Hao Peng, Heng Ji, and Graham Neubig.
Openhands: An open platform for AI software developers as generalist agents.
In *The Thirteenth International Conference on Learning Representations*, 2025a.
URL [https://openreview.net/forum?id=OJd3ayDDoF](https://openreview.net/forum?id=OJd3ayDDoF).
- Wang et al. (2025b)
Xingyao Wang, Boxuan Li, Yufan Song, Frank F. Xu, Xiangru Tang, Mingchen Zhuge, Jiayi Pan, Yueqi Song, Bowen Li, Jaskirat Singh, Hoang H. Tran, Fuqiang Li, Ren Ma, Mingzhang Zheng, Bill Qian, Yanjun Shao, Niklas Muennighoff, Yizhe Zhang, Binyuan Hui, Junyang Lin, Robert Brennan, Hao Peng, Heng Ji, and Graham Neubig.
Openhands: An open platform for AI software developers as generalist agents.
In *The Thirteenth International Conference on Learning Representations*, 2025b.
URL [https://openreview.net/forum?id=OJd3ayDDoF](https://openreview.net/forum?id=OJd3ayDDoF).
- Wei et al. (2025)
Yuxiang Wei, Olivier Duchenne, Jade Copet, Quentin Carbonneaux, Lingming Zhang, Daniel Fried, Gabriel Synnaeve, Rishabh Singh, and Sida I Wang.
Swe-rl: Advancing llm reasoning via reinforcement learning on open software evolution.
*arXiv preprint arXiv:2502.18449*, 2025.
- Williams (1992)
Ronald J Williams.
Simple statistical gradient-following algorithms for connectionist reinforcement learning.
*Machine learning*, 8(3):229–256, 1992.
- Xia et al. (2024)
Chunqiu Steven Xia, Yinlin Deng, Soren Dunn, and Lingming Zhang.
Agentless: Demystifying llm-based software engineering agents.
*arXiv preprint arXiv:2407.01489*, 2024.
- Xie et al. (2025)
Chengxing Xie, Bowen Li, Chang Gao, He Du, Wai Lam, Difan Zou, and Kai Chen.
SWE-fixer: Training open-source LLMs for effective and efficient GitHub issue resolution.
In Wanxiang Che, Joyce Nabende, Ekaterina Shutova, and Mohammad Taher Pilehvar (eds.), *Findings of the Association for Computational Linguistics: ACL 2025*, pp. 1123–1139, Vienna, Austria, July 2025. Association for Computational Linguistics.
ISBN 979-8-89176-256-5.
doi: 10.18653/v1/2025.findings-acl.62.
URL [https://aclanthology.org/2025.findings-acl.62/](https://aclanthology.org/2025.findings-acl.62/).
- Yang et al. (2025a)
An Yang, Anfeng Li, Baosong Yang, Beichen Zhang, Binyuan Hui, Bo Zheng, Bowen Yu, Chang Gao, Chengen Huang, Chenxu Lv, et al.
Qwen3 technical report.
*arXiv preprint arXiv:2505.09388*, 2025a.
- Yang et al. (2024a)
John Yang, Carlos E Jimenez, Alexander Wettig, Kilian Lieret, Shunyu Yao, Karthik Narasimhan, and Ofir Press.
Swe-agent: Agent-computer interfaces enable automated software engineering.
*Advances in Neural Information Processing Systems*, 37:50528–50652, 2024a.
- Yang et al. (2025b)
John Yang, Kilian Leret, Carlos E Jimenez, Alexander Wettig, Kabir Khandpur, Yanzhe Zhang, Binyuan Hui, Ofir Press, Ludwig Schmidt, and Diyi Yang.
Swe-smith: Scaling data for software engineering agents.
*arXiv preprint arXiv:2504.21798*, 2025b.
- Yang et al. (2025c)
John Yang, Kilian Lieret, Carlos E. Jimenez, Alexander Wettig, Kabir Khandpur, Yanzhe Zhang, Binyuan Hui, Ofir Press, Ludwig Schmidt, and Diyi Yang.
Swe-smith: Scaling data for software engineering agents, 2025c.
URL [https://arxiv.org/abs/2504.21798](https://arxiv.org/abs/2504.21798).
- Yang et al. (2024b)
Zonghan Yang, Peng Li, Ming Yan, Ji Zhang, Fei Huang, and Yang Liu.
ReAct Meets ActRe: Autonomous Annotation of Agent Trajectories for Contrastive Self-Training.
In *First Conference on Language Modeling*, 2024b.
URL [https://openreview.net/forum?id=0VLBwQGWpA](https://openreview.net/forum?id=0VLBwQGWpA).
- Yang et al. (2024c)
Zonghan Yang, An Liu, Zijun Liu, Kaiming Liu, Fangzhou Xiong, Yile Wang, Zeyuan Yang, Qingyuan Hu, Xinrui Chen, Zhenhe Zhang, Fuwen Luo, Zhicheng Guo, Peng Li, and Yang Liu.
Position: Towards Unified Alignment Between Agents, Humans, and Environment.
In Ruslan Salakhutdinov, Zico Kolter, Katherine Heller, Adrian Weller, Nuria Oliver, Jonathan Scarlett, and Felix Berkenkamp (eds.), *Proceedings of the 41st International Conference on Machine Learning*, volume 235 of *Proceedings of Machine Learning Research*, pp. 56251–56275. PMLR, 21–27 Jul 2024c.
URL [https://proceedings.mlr.press/v235/yang24p.html](https://proceedings.mlr.press/v235/yang24p.html).
- Zeng et al. (2025)
Liang Zeng, Yongcong Li, Yuzhen Xiao, Changshi Li, Chris Yuhao Liu, Rui Yan, Tianwen Wei, Jujie He, Xuchen Song, Yang Liu, et al.
Skywork-swe: Unveiling data scaling laws for software engineering in llms.
*arXiv preprint arXiv:2506.19290*, 2025.
- Zhang et al. (2025)
Linghao Zhang, Shilin He, Chaoyun Zhang, Yu Kang, Bowen Li, Chengxing Xie, Junhao Wang, Maoquan Wang, Yufan Huang, Shengyu Fu, et al.
Swe-bench goes live!
*arXiv preprint arXiv:2505.23419*, 2025.

## Appendix

## Appendix A Details of Mid-training

We curate a mid-training data recipe with a focus on enhancing SWE capabilities. Central to this effort is the collection of pull request (PR) data from GitHub, which provides extensive coverage of real-world bug fixes, feature requests, and code enhancements. To ensure data quality, we apply two filters: (i) we only retain repositories that have accumulated at least five GitHub stars, thereby excluding sparsely maintained projects with limited community engagement; and (ii) we remove any repositories overlapping with the SWE-bench benchmark (Jimenez et al., 2023) to prevent potential data leakage. For each candidate repository, we query the GitHub API for all PRs with the state MERGED, while discarding those abandoned, superseded, or left under review. To preserve more context information, we also snapshot the entire codebase at the base commit before the first code change in the PR.

After data crawling, we incorporate two complementary forms for the natural code change data: (i) natural diff patches and (ii) PR commit packs. A natural diff patch consolidates all commits in a PR into the final code difference, typically expressed as SEARCH–REPLACE blocks. This format aligns with the Agentless paradigm, in which the model must directly output the final patch. In contrast, a commit pack captures the sequence of human-authored commits within a PR, where each commit message (textual reasoning) is paired with the corresponding code modification (action). This structure closely parallels the SWE-Agent setting, where intermediate reasoning steps are interleaved with actions. However, the distinction of the utilities for the two types of data is not absolute: commit messages in a PR commit pack can still inform the model’s knowledge and indirectly strengthen its reasoning ability in the Agentless setting.

Natural diff patches. The natural diff patches used in the mid-training data recipe are processed with the following rules:

- •
Incorporate the agentless prompt template (see Prompts [1](https://arxiv.org/html/2509.23045v2#LST1),[2](https://arxiv.org/html/2509.23045v2#LST2),[3](https://arxiv.org/html/2509.23045v2#LST3),[4](https://arxiv.org/html/2509.23045v2#LST4); These four prompt templates are also used in the later stages, including cold-start, RL, and test-time self-play), and apply a loss mask to the prompt part. For the localization prompt, the response is set as the files modified in the ground-truth diff patch.
- •
If a related issue to the PR exists, use its content of the related issue; otherwise, use the PR title as the surrogate of the issue content.
- •
If a related issue to the PR exists, prepend the issue discussion at the beginning of the output in the code edit response. We aim to strengthen the model’s capability of code edit reasoning by leveraging the discussion contents.
- •
Discard PRs that include modifications to files other than {.py, .md, .rst}.
- •
For PRs containing {.md, .rst} file modifications, retain only the Python diffs and rewrite them into SEARCH–REPLACE blocks.
- •
Remove PRs involving file additions or deletions.
- •
For the code edits with only line insertions or deletions, preserve the original Git diff hunks as the SEARCH content in the SEARCH–REPLACE blocks.
- •
Ensure that no more than three Python files are modified per PR.
- •
Apply a filtering script to exclude PRs with non-{.py, .md, .rst} modifications, or PRs modifying more than three Python files.
- •
Further exclude PRs containing more than five SEARCH–REPLACE blocks.

A total of $\sim$50B tokens for natural diff patches are obtained after applying these filtering rules.

Figure: Listing 1: Agentless prompt template: Localization for BugFixer.

Figure: Listing 2: Agentless prompt template: Localization for TestWriter.

Figure: Listing 3: Agentless prompt template: Code edit for BugFixer.

Figure: Listing 4: Agentless prompt template: Code edit for TestWriter.

PR commit packs. The PR commit packs used in the mid-training data recipe are processed with the following rules:

- •
Discard PRs that include modifications to files other than {.py, .md, .rst}.
- •
For {.md, .rst} file modifications, retain the “diff –git” signature but remove the actual content changes.
- •
Ensure that each PR modifies at most five Python files (with at least one required). PRs exceeding this limit are discarded.
- •
Apply a filtering script to exclude PRs containing non-{.py, .md, .rst} file modifications or those modifying more than five Python files.
- •
Filter out all of the developer signatures and GitHub IDs for ethics considerations.

A total of $\sim$20B tokens for PR commit packs are obtained after applying these filtering rules.

In addition, we incorporate synthetic data to further enhance both the reasoning and agentic capabilities of the model. A key observation is that the ground-truth reward for the localization stage in the Agentless setting can be derived directly from the diff patch, since the set of files requiring modification is explicitly indicated.

Synthetic reasoning data. To improve reasoning quality, we perform a lightweight SFT of the Qwen-2.5-72B-Instruct model on 2,000 R1 trajectories. The resulting model is then used to generate large-scale rollouts for the localization stage of both BugFixer and TestWriter. We retain only the rollouts that achieve exactly correct file localizations. This procedure yields approximately $\sim$10B tokens of reasoning-intensive data dedicated to Agentless localization in the mid-training recipe.

Synthetic agentic interactions. To strengthen agentic capabilities, we simulate agent–environment interactions with a custom tool set designed to mimic file-system operations without execution. This design is motivated by practical constraints: while repository snapshots from GitHub are available, not all snapshots are equipped with an executable Docker environment. As a result, shell commands are disabled. Instead, we introduce synthetic tools that allow the agent to view file contents and perform keyword-based search for localization, which effectively reproduces the first stage of Agentless but in an agentic manner. The specification of this tool set is covered in the system prompt, which is then used to elicit agentic interaction rollouts from the Qwen-2.5-72B-Instruct model. The complete system prompt is provided in Prompt [5](https://arxiv.org/html/2509.23045v2#LST5). We apply a loss mask only to the system prompt, and enable the model to simultaneously learn both actions and observations along the trajectory, inspired by Yang et al. (2024b). This approach integrates both policy and world modeling into mid training.

Figure: Listing 5: A non-execution set of tools empowering the simulation of agentic interaction trajectories.

After completing the initial localization stage, the agent is guided into the code-editing phase through a follow-up instruction: “Now let’s move on to Stage 2 and edit the updates. Remember, you can still decide at any point whether a file actually requires modification.” We retain partial rollouts from Stage 1, provided that the localization results include at least one correct file.

In Stage 2, we first simulate the agent’s interaction by allowing it to open incorrectly localized files, and we artificially inject agentic reasoning patterns such as “I realize that I do not need to modify this file” after inspecting the file content. This procedure is designed to strengthen the self-reflection ability of the agent by exposing it to false-positive contexts regarding the issue to be solved.

Subsequently, we transcribe the ground-truth PR commit pack into trajectory form: each commit message is treated as the agent’s reasoning step, and each code update is represented as the corresponding action, expressed through the “str_replace” or “insert” tools. These interactions are appended to the trajectory, followed by a terminating “stop” call. Due to storage constraints on repository snapshots, this trajectory simulation is applied to only a subset of PRs. Overall, this process contributes approximately $\sim$10B tokens of agentic interaction data to the mid-training recipe. Future directions for scaling this component in the data recipe include leveraging the idea of environment scaling (Yang et al., 2025c).

Training. We perform mid-training using a standard next token prediction approach, initialized from the Qwen2.5-72B-Base (Qwen et al., 2024) model. We upsample the synthetic part of the data by a factor of 4 during mid-training, inspired by the practice in Grattafiori et al. (2024); Qwen et al. (2024); Gu et al. (2025). A global batch size of 256 with a maximum sequence length of 32K tokens is used, optimizing for long-context capabilities necessary for real-world software engineering tasks. The learning rate is set to 2e-5, with a cosine decay schedule and a minimum learning rate of 2e-6. The warm-up phase covers over approximately 3 billion tokens, followed by learning rate decay until approximately 150 billion tokens are processed.

## Appendix B Docker environments

**Table 3: The sources of the docker environments used in the development of Kimi-Dev.**
| Dataset Name | Dataset Link | Number of Dockers |
| --- | --- | --- |
| SWE-Gym (Pan et al. (2024)) | [https://huggingface.co/datasets/SWE-Gym/SWE-Gym/](https://huggingface.co/datasets/SWE-Gym/SWE-Gym/) | 2,356 |
| SWE-bench-extra (Badertdinov et al. (2024a)) | [https://huggingface.co/datasets/nebius/SWE-bench-extra/](https://huggingface.co/datasets/nebius/SWE-bench-extra/) | 3,846 |
| R2E-Gym-Lite (Jain et al. (2025)) | [https://huggingface.co/datasets/R2E-Gym/R2E-Gym-Lite](https://huggingface.co/datasets/R2E-Gym/R2E-Gym-Lite) | 3,671 |

Docker environment construction. To validate non-ground-truth patches generated by model rollouts and expand our dataset, we required executable Docker environments. We combined publicly available datasets with custom-configured Docker environments (see Table. [3](https://arxiv.org/html/2509.23045v2#A2.T3)). Among them, SWE-Gym and R2E-Gym-Lite open-source their dockers that we can directly use.
For datasets lacking Docker support (SWE-Bench-Extra), we implemented an automated configuration method:

- 1.
Initialize a Docker environment with fixed dependencies.
- 2.
Select Python version based on commit year.
- 3.
Install dependencies via requirements.txt and “pip install -e .”.
- 4.
Resolve ModuleNotFound errors during test execution.
- 5.
Validate success if a FAIL_TO_PASS test transitions from failing (without gt_patch) to passing (with gt_patch).

Out of 6.38k SWE-bench-extra instances, 3,846 environments are successfully constructed and subsequently used for cold-start and RL training.

## Appendix C More Details of RL training

### C.1 Prompt set selection

Figure: Figure 7: Ablation of positive example reinforcement during 72B Bugfixer RL.
Refer to caption: figs/sec3_rl_scaling/RL_bugfix_ablation_figure.png

In the main text, we introduce the adaptive prompt selection method for RL training. Specifically, we construct an initial prompt set of 1,200 problems by selecting those with pass@16 $>$ 0 from SWE-Gym (Pan et al., 2024), SWE-bench-extra (Badertdinov et al., 2025), and R2E-gym (Jain et al., 2025). Then, every 100 training steps, we expand the prompt set by adding 500 new problems. These additional problems are randomly sampled and filtered from the pool of problems for which the current model has pass@16 = 0, thereby progressively increasing the difficulty and forming a proper curriculum.

### C.2 RL experiment ablation

Figure [8](https://arxiv.org/html/2509.23045v2#A3.F8) shows the performance of the Qwen2.5-14B model in RL experiments, where both the BugFixer and the TestWriter exhibit clear scaling law behavior.

Figure: (a) 14B BugFixer
Refer to caption: figs/sec3_rl_scaling/quick_plot_M3_bf.png

Furthermore, Figure [7](https://arxiv.org/html/2509.23045v2#A3.F7) illustrates the effect of our proposed positive example reinforcement. We incorporated this improvement in the later stage of training and found that the RL of BugFixer achieved better performance compared to not using this trick. The main reason is that positive examples can reinforce the correct reasoning patterns, enabling the model to converge more quickly, especially when its exploration ability diminishes in the later stages. It is noticed that a similar trick was also applied in the development of the Seed1.5-thinking model (Seed et al., 2025).

## Appendix D Agent Infrastructure

We present a unified sandbox architecture designed for hybrid cloud cluster environments, leveraging Kubernetes orchestration to provide researchers with a flexible, secure, and highly scalable code execution platform. The architecture is accessible through a Python SDK and implements an ephemeral, use-and-destroy paradigm that ensures resource efficiency and security isolation. The system demonstrates exceptional scalability, supporting over 10,000 concurrent sandbox instances while maintaining performance stability. This infrastructure serves as a foundational platform for diverse computational scenarios, including automated code evaluation and RL experiments.

The system employs a sidecar container pattern to efficiently orchestrate and manage a heterogeneous collection of over 25,000 docker images sourced from multiple datasets. This architectural choice enables optimal resource utilization while maintaining isolation between different execution environments. Additionally, we have developed a proprietary Software Engineering (SWE) image-building pipeline that continuously expands the repository of supported images, thereby enhancing the system’s adaptability to diverse computational workloads and research requirements.

## Appendix E Case Studies under Agentless

### E.1 Bugfixer Traces

We provide a Bugfixer’s response trace during the code repair stage (see Listing [6](https://arxiv.org/html/2509.23045v2#LST6)). From this, we can observe that the initial code given was return self[i, j - pos - other.cols], but the model quickly realized its mistake and corrected it to return self[i, j - other.cols]. Although some repetitive self-reflections followed, the increasing response length indeed improved answer accuracy and robustness in our experiments.

Figure: Listing 6: Reasoning trajectory example for BugFixer.

### E.2 Testwriter False Positive Cases

During the RL training process, we observed that the Testwriter component exhibits some false positives, which can result in tests that contain certain gaps. This might cause the test patches generated by the model to be mistakenly considered as correct. Consequently, the performance improvement of Testwriter does not accurately reflect the actual performance. In this section, we provide two intuitive examples to illustrate this phenomenon, and leave further enhancement for TestWriter as future work.

Listing [7](https://arxiv.org/html/2509.23045v2#LST7) shows the ground-truth test patch for instance django__django-16877, with Listing [8](https://arxiv.org/html/2509.23045v2#LST8) showing the test patch generated by theTestWriter. A detailed comparison reveals that the model-generated test cases are not comprehensive: Two locations should have been tested, but only one was checked, and the effect of mark_safe was not considered. In practice, this allowed the model-predicted patch to pass the TestWriter reward check, but result in a false positive.

The second example instance is sympy__sympy-13974, with Listings [9](https://arxiv.org/html/2509.23045v2#LST9) and [10](https://arxiv.org/html/2509.23045v2#LST10) showing the ground-truth and model-generated test patches. In this case, the coverage of the generated test is also insufficient. The generated test does not account for the need to satisfy the associativity property, e.g., assert tensor_product_simp(TP(A, B)**x) == TP(A**x, B**x). As a consequence, it fails to serve as a reliable judge for BugFixer.

Figure: Listing 7: GT test patch of django__django-16877.

Figure: Listing 8: Model predicted test patch of django__django-16877.

Figure: Listing 9: GT test patch for sympy__sympy-13974.

Figure: Listing 10: Model predicted test patch of sympy__sympy-13974.

## Appendix F Emergent Parallel scaling in Kimi-Dev

Figure: Figure 9: Emergent parallel scaling results on SWE-bench Verified.
Refer to caption: figs/sec3_sp_scaling/parellel_scaling_figure.png

Compared to the self-play method that leverages execution during test time, parallel scaling (Chen et al., 2025b; Pan et al., 2025) is a recently-introduced test-time scaling method that aggregates multiple independent rollouts for additional improvement. While previous works incentivize the ability of parallel scaling through training, or train a separate reward model (Pan et al., 2024; Jain et al., 2025) for patch selection, we observe that the parallel scaling effect emerges in our model without any specific training.
Specifically, patch candidates from parallel rollouts of BugFixer are used to prompt the model to summarize their differences and compose a new bugfix patch. Listing [11](https://arxiv.org/html/2509.23045v2#LST11) is the prompt template of parallel scaling. In the template, promblem_statement is the GitHub issue, and trajs_content represents the content of multiple patch candidates.

Figure: Listing 11: The prompt template for parallel scaling.

The results in Figure [9](https://arxiv.org/html/2509.23045v2#A6.F9) show that the performance of the parallel aggregation improves as the number of patch candidates in the prompt increases. The advantage of this scaling paradigm over majority voting lies in its ability to leverage the model’s own capacity to analyze multiple candidate patches, thereby surpassing the simplistic approach of weighting answers merely by their frequency of occurrence. Listing [12](https://arxiv.org/html/2509.23045v2#LST12) covers a full prompt example with 14 different input patch candidates.
Note: As Listing [12](https://arxiv.org/html/2509.23045v2#LST12) is long, it is OK to jump to Listing [13](https://arxiv.org/html/2509.23045v2#LST13) to directly observe the model behavior.

Figure: Listing 12: Example of emergent parallel scaling (cdent__gabbi-191 in SWE-bench-extra), the prompt input part.

Listing [13](https://arxiv.org/html/2509.23045v2#LST13) shows how the model successfully recognizes the correct answer candidate in Listing [12](https://arxiv.org/html/2509.23045v2#LST12), and generates a novel patch with additional reasoning to solve the issue:

Figure: Listing 13: Example of emergent parallel scaling (cdent__gabbi-191 in SWE-bench-extra), the model response part.

## Appendix G Analysis for SWE-Agents

### G.1 Stage Annotation for SWE-Agent Trajectories

In this section, we present how we use a frontier LLM to annotate the SWE-Agent stage to which each interaction turn within the trajectory rollout belongs. While we have briefly introduced the five stages suggested in the prompt of the SWE-Agent prompt in Section [4](https://arxiv.org/html/2509.23045v2#S4), we attach the excerpt in Listing [14](https://arxiv.org/html/2509.23045v2#LST14) for greater clarity:

Figure: Listing 14: The excerpt of the five-stage declaration in the SWE-Agent prompt.

It should be noted that the agent could flexibly transit across the five stages during its working process. For example, after Stage 4 when the agent rerun the test script, possibilities are that erroneous information remains, and this is when the agent goes back to Stage 3 to refine its code repair with reflection; Similar backtracing behavior could be observed from Stage 5 to Stage 3 as well, where the initial code repair has proven correct under the initial test script the agent composes in Stage 2, but fails some edge testcase the agent proposes in Stage 5.

To further analyze the BugFixer and the reflection skill prior, we need to realize which stage each turn along the SWE-Agent trajectory belongs to. As no strict boundaries or special prompt notes are set between each consecutive stage, we leverage an LLM for annotation. The annotation system prompt we set in kimi-k2-0711-preview is shown in Listing [15](https://arxiv.org/html/2509.23045v2#LST15):

Figure: Listing 15: The annotation prompt for SWE-Agent stages.

To provide a clearer understanding of the trajectory, we incorporate most of the tool descriptions and instructions from the SWE-Agent system prompt into the annotation system prompt. The annotation is conducted in a multi-round manner, leveraging the agent’s previous actions and observations, as well as the stage classifications of earlier turns, to better exploit contextual information. At the $i$-th round of annotation, the observation–action pair from turn $i$ of the SWE-Agent trajectory is appended as input, and the annotator is expected to output the corresponding stage classification.

### G.2 Comparative Study

Based on the automatic stage annotation in the above section, we present a comparative study by inspecting the performance on sympy__sympy-20590 among the Kimi-Dev under Agentless, and each of the Base, MT, SFT, and RL priors with SWE-Agent adaptation.

The problem statement of sympy__sympy-20590 is listed in Listing [16](https://arxiv.org/html/2509.23045v2#LST16):

Figure: Listing 16: The problem statement of sympy__sympy-20590.

It is observed that the main difficulty in resolving the issue lies in the realization of the “some parent class” referenced in the problem. In fact, the hints text of this problem, which reflects the discussion of the developers under the original issue, reveals a much more in-depth investigation into the issue (Listing [17](https://arxiv.org/html/2509.23045v2#LST17)):

Figure: Listing 17: The excerpted hints text of sympy__sympy-20590.

According to the discussion, it is clear that the code repair would be to “add empty slots to DefaultPrinting”, which naturally leads to the navigation towards the file related to the implementation of the printer (sympy/core/_print_helpers.py, which is also the file updated by the ground-truth patch.) However, the hints_text information in the test set is not allowed to be used in the problem-solving process, which challenges the reasoner or the agent to figure out “the parent class that stopped defining ‘__slots__‘ ” autonomously.

We first examine Kimi-Dev under Agentless. None of the 40 runs succeeded in producing the correct file localization. In most cases, the updates are made to sympy/core/symbol.py, which is a plausible choice since the reported problem is triggered by sympy.Symbol(’s’), and symbol.py should contain the definition of the Symbol class. This line of reasoning, however, diverges from the correct solution. A small number of runs attempt alternative localizations, such as sympy/core/{basic.py, expr.py}, but these are also incorrect.

The limitation of the Agentless framework becomes more obvious when the focus is shifted to the inspection over the SWE-Agent trajectories. For all of the Base, MT, SFT, and RL priors with SWE-Agent adaptation, the resulting trajectories always contain a test-reproducing phase (marked as Stage “2” by the annotator), with the generated script reads like:

Figure: Listing 18: An exampled reproducing script in Stage 2 within the SWE-Agent trajectories in sympy__sympy-20590.

It is trivial for an agent to generate a reproducing script of this form, as it directly transcribes the case described in the problem statement. Executing the script provides an unambiguous signal of whether the issue is resolved: the attribute s.__dict__ should no longer exist, and the expected Error: message should appear in the standard error output. Indeed, observing the initial completion of Stage 3 across all trajectories reveals that none of the agents succeeded on their first attempt. However, the incomplete status is consistently exposed in Stage 4, when the script is rerun and s.__dict__ still persists. This progression highlights the advantage of the SWE-Agent framework over the Agentless paradigm, as the agent is afforded additional opportunities for iterative refinement rather than being limited to a single attempt.

We continue to analyze the behavior of the agents adapted from the Base, MT, and SFT priors. Due to the difficulty of the issue, it is non-trivial to correctly localize the error through their agentic reasoning: the interactions show that the agents were switching among several file candidates, but failed to reach the correct one. The only exception comes from the agent adapted from the RL prior, which marks its unique success on this instance through accurate agentic reasoning. We attach the intermediate process from the initial Stage-3 moment to the Stage-3 revisit (refining the initial code repair) within the successful trajectory, tagged by the stage annotator:

Figure: Listing 19: The intermediate reflection process between the two Stage-3 moment of the successful trajectory in sympy__sympy-20590.

Listing [19](https://arxiv.org/html/2509.23045v2#LST19) shows the advanced reflection capability through slot checking along the entire class hierarchy, which successfully leads to the observation of the erroneous Printable. The following behavior from the agent includes the routine of test rerun, and the observation of passing the test script (Listing [18](https://arxiv.org/html/2509.23045v2#LST18)). This chain of actions recovers and resonates with the developer discussions in hints_text (Listing [17](https://arxiv.org/html/2509.23045v2#LST17)), showing the superior reflection skill in the RL prior over other priors.

### G.3 Generalization to Other Tasks

In this section, we study whether the skills incentivized by Agentless training and SWE-Agent adaptation through SWE-Smith trajectories could transfer to other SWE tasks. We use SWE-bench-live and SWE-bench Multilingual as our testbeds.

SWE-bench-live (Zhang et al., 2025) is a benchmark for real-world issue resolution, evaluating AI systems on software engineering tasks. Using an automated curation pipeline, it is updated monthly to ensure fresh tasks and rigorous, contamination-free evaluation. For our experiments, we selected the default set of 300 tasks, with data collected between October 2024 and March 2025. Compared to SWE-bench Verified, SWE-bench-live exhibits a higher degree of distributional shift.

SWE-bench Multilingual (Yang et al., 2025c) introduces 300 curated tasks from 42 GitHub repositories across 9 programming languages, including Rust, Java, PHP, Ruby, JavaScript/TypeScript, Go, and C/C++, covering domains such as web frameworks, data tools, core utilities, and libraries. Compared to SWE-bench Verified, which focuses exclusively on Python, SWE-bench Multilingual exhibits greater linguistic and domain diversity, posing additional challenges in cross-language generalization and transferability of software engineering capabilities.

Similar to previous experiments, we evaluated four model stages as the priors: the original Qwen2.5-72B (Base), the mid-trained model (MT), the model activated with reasoning data through supervised finetuning (SFT), and the model after RL training (RL). We still use the open-source SWE-smith trajectories to activate the agentic capabilities of each prior.

Figures [10](https://arxiv.org/html/2509.23045v2#A7.F10) and [11](https://arxiv.org/html/2509.23045v2#A7.F11) show the performance of the four priors on SWE-bench-Live and SWE-bench Multilingual under varied amounts of agentic trajectories for adaptation ($2^{21}$ as one-step gradient descent, $2^{23}$, $1.1\times 2^{27}$, and $1.5\times 2^{28}$ as 100, 2,000, and 5,016 training trajectories). Each SWE-Agent adaptation experiment is conducted through lightweight supervised finetuning, the training time of which ranges from several minutes to two hours at most.

Compared to the Base prior, those specifically enhanced with Agentless skills (SFT and RL) demonstrate stronger task generalization, especially under the data-scarce settings. However, when more SWE-Smith trajectories are used for adaptation, the performances of the Base and the MT priors become closer to those of the SFT and the RL priors. This could be attributed to the gaps between the different SWE tasks. The exploration for recipes that enable stronger out-of-distribution and task-agnostic generalization is left for future work.

Figure: (a) #SFT $=2^{21}$.
Refer to caption: figs/sec4_generalization_plots/l-100-s1.png

Figure: (a) #SFT $=2^{21}$.
Refer to caption: figs/sec4_generalization_plots/m-100-s1.png

## Appendix H Use of Large Language Models

The initial draft of this paper was written entirely by the authors. A large language model (gpt-5) was used only to aid with polishing the language (e.g., grammar and clarity). All conceptual contributions, experimental designs, analyses, and conclusions are the work of the authors.

## Peer Reviews

confidence: 4
contribution: 2
initial_rating: 6
presentation: 3
questions: - what is behind the roughly linear increase in token length in Figure 3 as RL training proceeds? You analyze some of these traces in Appendix F, observing that there are some repetitive self-reflections, although also noting that increased response length correlated with improved answer accuracy. How do you quantify this at scale? Is the length increase due to your choice of RL objective? Recent work (https://arxiv.org/pdf/2508.08221) has commented on this sequence length effect, albeit with a GRPO-style objective.
- How much do you attribute the performance improvements measured in both the Agentless framework evaluations and subsequent SWE-Agent evaluations to the dataset of DeepSeek R1 based reasoning trajectories? Looking at Figure 5, after $2^{23}$ SWE-Agent SFT tokens there is a large jump between the base model and MT checkpoint. What explains this?
soundness: 3
strengths: While advanced coding agent model training has been underway in model labs for certain years, there are relatively few detailed accounts of how to take a pre-trained model and effectively imbue it with the skills needed to solve software engineering problems. From this perspective, the work offers a valuable contribution, in particular the details of the mid-training procedure which appears to be the stage of Agentless training that yields the largest SWE-Bench Verified performance improvement after SFT on SWE-Agent traces; perhaps due to training the model to reproduce the motifs, reasoning patterns and skills required to conduct software engineering work. The work is of a reasonably large scale, and achieves compelling results on SWE-Bench Verified for a model of its size, with 60.4% resolution rate on SWE-Bench Verified with the Agentless-like framework.
summary: This work presents a training recipe that leverages workflow-based pipelines as opposed to more open-ended agentic rollouts in order to train an open-source code LLM for SWE tasks. The so-called Agentless training approach provides more stability and the opportunity to introduce intermediate skills, such as locating files, writing tests and fixing bugs, which may subsequently be used and composed together when training a SWE-agent model. Concretely, the authors describe: a mid-training procedure where data from GitHub issues and PR commits form examples of how developers reason about issues and fix bugs; a cold-start procedure where SWE-related reasoning traces from R1 are used to induce long CoT abilities; an RL stage where a policy gradient objective is used to train code editing capabilities with outcome-based rewards; and finally a test-time self-play stage where the model learns to play the roles of a BugFixer and TestWriter. Following this training procedure, the authors evaluate the resulting Kimi-Dev model on SWE-Bench Verified, achieving a strong performance of 60.4% for an open-weights 72B model derived from Qwen 2.5 (Base). The authors then investigate whether the structured Agentless training procedure leads to model checkpoints which offer useful "priors" for more open-ended SWE-agent fine-tuning. Indeed, various stages of the Agentless training procedure, in particular the mid-training, lead to a big uplift in SWE-Bench Verified performance after various amounts of SFT on SWE-Agent traces collected from Claude 3.5 Sonnet. The authors also demonstrate some evidence towards the RL prior (after the full Agentless training procedure) supporting a greater number of turns for SWE-Agent style rollouts after SFT.
weaknesses: While the Agentless performance for SWE-Bench Verified is reasonably strong at 60%, the pass@1 rate on the SWE-Agent results are somewhat low at 48.6%, particularly given the model is roughly double the size of other models obtaining comparable scores. It would be good to investigate why this is, and crucially whether this is as a result of the Agentless training procedure that preceded SFT for SWE-Agent.

Moreover, the authors train on the outputs of other models at two key points in the paper. This is disappointing since it effectively hides how the corresponding skills can be trained from scratch in an open-source model, instead deferring this to the black box of a preexisting model trained by some other lab. The first instance of this is during mid-training - which appears to be one of the steps in the training procedure which yields the greatest performance improvements - where traces from the DeepSeek's R1 model are used to introduce skills such as reasoning, problem analysis, method sketching, self-refinement and exploration of alternative solutions. This is an important procedure, and it would have been good to see discussion of how these skills could be bootstrapped without training on the outputs of a model which has already undergone this training. The second instance are the SWE-Agent traces used for SFT from Claude 3.5 Sonnet. While I understand that the primary focus of this paper is the Agentless training procedure itself, I do believe that any conclusions pertaining to the usefulness of this intermediate training procedure as a "prior" for training SWE-Agents must be made with a more legible training procedure for the SWE-Agent stage. In other words, had the jump from Agentless to SWE-Agent been achieved by a transparent RL procedure, then conclusions about the usefulness of the Agentless skill prior may be more impactful. Instead, we appear to have learned that these "priors" are useful when doing imitation learning from black-box model traces.

Finally, on the point about generalization, the studies all revolve around SWE-Bench style tasks (including the live and multilingual variants in Appendix E). These represent only a small subset of software engineering work, and do not address related tasks such as novel algorithm design, performance optimization, task management and so forth, which I believe would be a better quantifier of generalization than merely more up-to-date or polyglot variants of SWE-Bench's issue resolution task. Indeed, this is an area where the paper's Agentless training thesis may hold promise; where systematically created workflow-based mid-training procedures can imbue a model with a diverse range of useful skills which can be learned to be composed together in the RL stage.

Nits:
- L427: do you mean to say "The RL prior outperforms all the other models..."?

---

confidence: 5
contribution: 4
initial_rating: 8
presentation: 3
questions: - For weakness 1: it will nice to either (1) show the benefit of RL by demonstrating performance improvements on other datasets/metrics/settings (eg higher pass@k for large k); OR (2) discuss the limitation of agentless+RL in providing better prior
- For weakness 2: It will be nice to either (1) disprove it or (2) discuss the limitation
- For weakness 3, my question is: Given the same computation budget, what if we perform distillation on the same set of training tasks (eg, swe-smith, swe-gym) -- Is it possible that the performance gain we get there will be larger than the one we get with agentless as prior? If so, why is it a good idea to use an agentless prior rather than directly generating data from environments that better match the domain?
soundness: 3
strengths: - This paper exercises a principled recipe and delivers strong results under agentic settings. The staged recipe (mid-training on ~150B tokens; 50B natural diffs, 20B PR commit packs, ~20B synthetic, upsampled ×4; reasoning-heavy cold start; RL with outcome-only rewards; test-time self-play) is coherent and empirically validated. The paper achieves 60.4% on SWE-bench Verified under a standardized 40 patch/40 test setting, with clear scoring for self-play selection.
- Agent transfer with small data. With only ~5k public SWE-Agent trajectories, the adapted model attains 48.6% pass@1
- The authors performed detailed experiments demonstrating the skill transfer and generalization effect by controlling for different prior models. These experiments provide valuable insights into how the community can improve future agent models.
summary: The paper argues that “agentless” workflow training can serve as skill priors (localization, code edit, self-reflection) for end-to-end SWE agents. It introduces Kimi-Dev, a 72B open-weight code LLM trained via a curated recipe (mid-training on PR/issue data, a reasoning-heavy cold start, RL on code edits, and test-time self-play). Under a workflow (agentless) setup, Kimi-Dev reaches 60.4% on SWE-bench Verified; with 5k public SWE-Agent trajectories for light SFT, the model attains 48.6% pass@1 in a multi-turn agent framework, comparable to Claude 3.5 Sonnet (241022). These results aim to bridge workflow and agentic paradigms by treating agentless training as a foundation for agent adaptation.
weaknesses: - It is unclear to me that RL is an indispensable part of the recipe: In Figure 5, the performance difference between the RL and the SFT curves is relatively small. Does this demonstrate that the RL part is not really the essential part of the recipe—SFT on an agentless task is already sufficient to provide such a prior to improve the upper bound on performance given sufficient multi-turn agent SFT data?
- Unclear if Agentless Skill prior will still be useful given sufficient multi-turn SFT data: Also in Figure 5, when given sufficient agent SFT data, the performance of MT gets very close to SFT/RL. Does that mean the value of agentless skill prior drops as you have access to more in-domain agent SFT data?
- Unclear if performance improvements come from distilling from a stronger model: If I understand correctly, the SFT data for agentless skill was distilled from Deepseek R1 (section 3.2) - could the effectiveness of "agentless prior" come from distillation from the Deepseek R1 model?

---

confidence: 4
contribution: 2
initial_rating: 6
presentation: 3
questions: N/A
soundness: 3
strengths: The main discovery of agent less training can induce skill that make further agent training more effective is interesting: it opens up a new paradigm how researchers may train their agent. The open source of the recipe further add to the contribution.
The proposed multi-stage training recipe is well-explained and reflect the researcher’s understanding of the nuances in scaling SWE models.
The empirical results of the trained model is strong, achieving SOTA among open-sourced models for workflow-based approaches on SWE-bench, and competitive pass@1 performance under agentic framework. This shows the method’s effectiveness.
The analysis of the paper is very insightful, including the varying of token budget, RL progression, etc. All of these settings reflects a solid experimental approach.
summary: The paper introduces Kimi-Dev, an open-source LLM for software engineering that unifies agentless and agentic approaches. It shows that agentless training through modular tasks can build transferable skill priors that make subsequent agentic finetuning more efficient. Kimi-Dev achieves SOTA on SWE-bench Verified and enables competitive SWE-agent results with minimal additional training.
weaknesses: Some technical details are deferred to the appendix. The main context only gives a final evaluation formula while the concrete implementations of reward, prompt sampling, etc. are not rigorously and clearly laid out in the main text.
There are some observations about false positive mentioned, but the paper can further benefit from providing quantitative and qualitative analysis of the error remaining given the current bug fixer and test writer, especially points that can reflect the challenges in agentic skill prior transfer.
Much of the justification for skill transfer from agent less to agentic framework is empirical. As the core discovery of the paper, more principled proof or study about how skill prior linked to generalization and how these skills are manifested will further strengthen the claim.

---

confidence: 4
contribution: 3
initial_rating: 8
presentation: 3
questions: 1. What is the precise configuration of SFT used for Figure 5? While the number of trajectories is clearly specified, what is the number of training epochs? Were hyperparameters tuned independently for each experimental run, or was a single configuration used across all conditions?
2. What are your thoughts on the TestWriter false positive examples documented in the appendix, and how might this limitation be addressed in future work?
soundness: 3
strengths: 1. The paper is well-written with clear separation and explanation of each component, making the methodology easy to understand and follow.
2. The ablation studies (Figure 5) systematically isolate the contributions from mid-training, cold-start, and RL stages, providing clear illustration of each component's contribution. The sweep over different amounts of SWE-Agent SFT data (from 0 to ~1.5×2^28 tokens) is particularly comprehensive.
3. The reported performance of 60.4% on SWE-bench Verified within the Agentless scaffolding using Qwen2.5-72B as the base model is impressive.
4. The extensive appendices document data recipes, training procedures, and infrastructure details in substantial depth, significantly enhancing the work's reproducibility.
summary: This paper proposes a two-stage training approach for software engineering (SWE) agents: first training on "Agentless" workflows (fixed pipeline tasks such as bug localization and repair), then adapting to multi-turn agentic frameworks. The authors introduce Kimi-Dev, a 72B parameter model that achieves 60.4% on SWE-bench Verified through Agentless training, and 48.6% when adapted to the SWE-Agent framework with only 5k trajectories.

The central thesis is that Agentless training, framed as a single-turn task, facilitates more scalable RL training and serves as an effective prior for transitioning to multi-turn scaffoldings.
weaknesses: 1. The anomalous performance dip of the "SFT" prior at 2^24 tokens (Figure 5) raises questions about the stability and reliability of the proposed priors. Including confidence intervals would help clarify whether the observed differences between priors are statistically significant or within the margin of experimental noise.
2. The 5k SFT trajectories represent a relatively small subset of potential teacher data. Given that Claude 3.7 Sonnet is a substantially stronger model, there may be a scenario where scaling the number of trajectories could narrow the gap between the Base and Kimi-Dev priors. If this is the case, the proposed approach would offer a more efficient rather than more powerful method for training multi-turn SWE agents, which represents a weaker claim that it could be otherwise.
3. While the Agentless checkpoint demonstrates strong performance as a prior for multi-turn adaptation, it remains unclear whether directly applying large-scale RL to the SWE-Agent framework would yield comparably strong or weaker results. The literature includes examples of applying GRPO (DAPO) to sparse reward settings for LLMs in SWE tasks, such as DeepSWE [1]. A direct comparison or discussion of this alternative training paradigm would strengthen the paper's claims about the necessity and superiority of the two-stage approach.

[1] Michael Luo et al. DeepSWE: Training a State-of-the-Art Coding Agent from Scratch by Scaling RL


Decision: Accept (Poster)