Paper deep dive
Scaling Coding Agents via Atomic Skills
Yingwei Ma, Yue Liu, Xinlong Yang, Yanhao Li, Kelin Fu, Yibo Miao, Yuchong Xie, Zhexu Wang, Shing-Chi Cheung
Intelligence
Status: succeeded | Model: google/gemini-3.1-flash-lite-preview | Prompt: intel-v1 | Confidence: 94%
Last extracted: 4/10/2026, 2:57:51 AM
Summary
The paper introduces a scaling paradigm for LLM coding agents by shifting from task-level optimization to mastering five fundamental 'atomic skills': code localization, code editing, unit-test generation, issue reproduction, and code review. By employing a joint reinforcement learning (RL) framework across these skills, the authors demonstrate improved performance on atomic tasks and significant generalization to unseen composite coding tasks, outperforming traditional task-specific training.
Entities (5)
Relation Signals (3)
Joint Reinforcement Learning → improves → Atomic Skills
confidence 95% · In this manner, atomic skills are consistently improved without negative interference or trade-offs between them.
Atomic Skills → generalizesto → Composite Coding Tasks
confidence 92% · Notably, we observe that improvements in these atomic skills generalize well to other unseen composite coding tasks
GRPO → stabilizes → Joint Reinforcement Learning
confidence 90% · We employ Group-based Relative Policy Optimization (GRPO) Shao et al. (2024) to stabilize training
Cypher Suggestions (0)
No Cypher suggestions yet.
Abstract
Abstract:Current LLM coding agents are predominantly trained on composite benchmarks (e.g., bug fixing), which often leads to task-specific overfitting and limited generalization. To address this, we propose a novel scaling paradigm that shifts the focus from task-level optimization to atomic skill mastery. We first formalize five fundamental atomic skills, code localization, code editing, unit-test generation, issue reproduction, and code review, that serve as the basis vectors for complex software engineering tasks. Compared with composite coding tasks, these atomic skills are more generalizable and composable. Then, we scale coding agents by performing joint RL over atomic skills. In this manner, atomic skills are consistently improved without negative interference or trade-offs between them. Notably, we observe that improvements in these atomic skills generalize well to other unseen composite coding tasks, such as bug-fixing, code refactoring, machine learning engineering, and code security. The observation motivates a new scaling paradigm for coding agents by training with atomic skills. Extensive experiments demonstrate the effectiveness of our proposed paradigm. Notably, our joint RL improves average performance by 18.7% on 5 atomic skills and 5 composite tasks.
Tags
Links
- Source: https://arxiv.org/abs/2604.05013v1
- Canonical: https://arxiv.org/abs/2604.05013v1
Trouble viewing inline? Open PDF directly →
Full Text
70,509 characters extracted from source content.
Expand or collapse full text
Preprint Scaling Coding Agents via Atomic Skills Yingwei Ma 1∗ Yue Liu 2∗ Xinlong Yang 3 Yanhao Li 3 Kelin Fu 3 Yibo Miao 4 Yuchong Xie 1 Zhexu Wang 5 Shing-Chi Cheung 1 1 HKUST 2 NUS 3 PKU 4 SJTU 5 BUPT yliu@u.nus.edu ∗ denotes the equal contribution. Abstract Current LLM coding agents are predominantly trained on composite bench- marks (e.g., bug-fixing), which often leads to task-specific overfitting and limited generalization. To address this, we propose a novel scaling paradigm that shifts the focus from task-level optimization to atomic skill mastery. We first formalize five fundamental atomic skills—code local- ization, code editing, unit-test generation, issue reproduction, and code review—that serve as the ”basis vectors” for complex software engineering tasks. Compared with composite coding tasks, these atomic skills are more generalizable and composable. Then, we scale coding agents by performing joint RL over atomic skills. In this manner, atomic skills are consistently im- proved without negative interference or trade-offs between them. Notably, we observe that improvements in these atomic skills generalize well to other unseen composite coding tasks, such as bug-fixing, code refactoring, machine learning engineering, and code security. The observation moti- vates a new scaling paradigm for coding agents by training with atomic skills. Extensive experiments demonstrate the effectiveness of our proposed paradigm. Notably, our joint RL improves average performance by 18.7% on 5 atomic skills and 5 composite tasks. 1 Introduction Large Language Models (LLMs) have achieved promising performance in real-world appli- cations, e.g., ChatBots (OpenAI, 2025). LLM coding agents serve as a foundational layer for a wide range of applications, such as vibe coding (Anthropic, 2025) and deep research (Deepmind, 2025). Pioneer work shapes the development of LLM coding agents by defining coding tasks such as bug-fixing Jimenez et al. (2023), terminal coding (Merrill et al., 2026), machine learning engineering (Chan et al., 2024), and research replication (Starace et al., 2025). Following this roadmap, prior studies (Ma et al., 2024; Guo et al., 2025; Yang et al., 2025c) scale code agents by training with these composite coding tasks. However, as shown in the left panel of Figure 2, we observe that training these composite coding tasks results in limited generalization. For example, training on the bug-fixing task does not generalize to the code refactoring task, as evidenced by Figure 1. Figure 1: RL on Bug Fixing vs. Joint RL on Atomic Skills. The y-axis shows relative perfor- mance improvement (%), and the x-axis covers five atomic skills and two composite tasks. We argue that this limitation stems from the ”black-box” nature of composite task training.Optimizing for a high-level goal (e.g., passing a test suite) without explicit supervision on the intermediate steps leads to brittle policies that mem- orize task-specific heuristics rather than learning robust problem-solving capabil- ities. Furthermore, scaling RL on com- posite tasks is practically intractable due to the infinite diversity of real-world soft- ware tasks and the difficulty of defining dense reward functions for a new domain. 1 arXiv:2604.05013v1 [cs.SE] 6 Apr 2026 Preprint To overcome these challenges, we propose a paradigm shift: instead of training agents to solve tasks, we train them to master the atomic skills required to solve any task. We hypothesize that complex software engineering workflows can be decomposed into a set of composable, generalizable basic skills. By analyzing representative coding workflows, we abstract five atomic skills: code localization, code editing, unit-test generation, issue reproduction, and code review. Figure 2: Composite Tasks vs. Atomic Skills. The left part denotes composite tasks such as bug-fixing and code refactoring. The right part denotes the decomposed atomic skills, such as issue reproduction, code editing, etc. We em- pirically find that the generalization ability of training on composite tasks is limited. Conduct- ing joint RL over atomic skills improves atomic skills and generalization to composite tasks. They are designed to follow three prin- ciples: an atomic skill is defined as a minimal, self-contained coding capabil- ity that 1) admits a precise specification of inputs and outputs, 2) can be indepen- dently evaluated with minimal ambiguity, and 3) serves as a reusable building block for solving more complex, composite cod- ing tasks. Then, we perform light super- vised fine-tuning (SFT) on the base model (pretrained model), excluding composite tasks, to initialize the agent’s atomic skills. To effectively learn multiple atomic cod- ing skills, we propose a joint reinforce- ment learning (RL) framework that trains a single coding agent with a shared pol- icy across all skills. Instead of optimiz- ing each skill in isolation, our approach samples tasks from a unified skills buffer and optimizes the agent under a single ob- jective, enabling positive transfer across skills. This joint training paradigm en- courages the emergence of shared repre- sentations for code understanding, execu- tion reasoning, and tool usage, and leads to consistent performance improvements across individual skills as well as strong generalization to unseen composite cod- ing tasks. In this manner, we provide an effective scaling paradigm for training coding agents. The contributions are as follows. • We analyze various composite coding tasks and formulate five atomic skills, guided by three design principles. • We propose a new scaling paradigm for coding agents by designing a scalable joint RL framework across five atomic skills. •Extensive experiments and analyses demonstrate the superiority and effectiveness of our proposed method. 2 Methods 2.1 Composable Atomic Skills Construction As mentioned above, our design principles for atomic skills emphasizes both evaluability and compositionality, which are essential for scalable agent training. Formally, each atomic skill s k induces a task distributionD k . A task instance is defined as a tuple as follows. τ = (k, x, c),(1) wherek ∈ 1,. . .,Kdenotes the atomic skill type,xis the task-specific input (e.g., issue description, code context, or code change), andcspecifies the execution context, including repository state and sandbox configuration. A single shared policyπ θ (y| x)parameterized 2 Preprint Figure 3: Overall Training Framework. byθmaps the inputxto a structured outputy. Each atomic skill is associated with a skill-specific reward function as follows. r k : (x, y)→ R,(2) which is computed by an automatic evaluator operating in a sandboxed execution envi- ronment. Based on an analysis of real-world software engineering workflows and existing coding benchmarks, we identify five atomic skills that frequently recur across diverse coding tasks. Code Localization Given a natural language issue description and a codebase, the agent is required to identify the set of files most relevant to the issue. The output is a ranked list of file paths. To construct supervision and rewards, we collect issues from GitHub and retrieve the corresponding pull requests that resolve them. The set of files modified in the ground-truth patch is treated as the reference localization target. The agent receives a positive reward if the predicted file set exactly matches the ground-truth file set, and a negative reward otherwise. This strict matching criterion intentionally encourages the agent to approximate the distribution of files selected by human developers, rather than merely identifying loosely related regions. Formally, letF ∗ ⊆Fdenote the set of files modified in the ground-truth patch, and let ˆ F(y) denote the file set predicted by the agent. The reward is defined as follows. r loc (x, y) = +1, if ˆ F(y) = F ∗ , −1, otherwise. (3) While conservative, this design avoids ambiguous partial credit and yields a well-defined reward signal suitable for reinforcement learning. Code EditingGiven a code context and an explicit edit instruction, the agent generates a patch that modifies the code accordingly. Edits may include bug fixes or targeted feature changes. The correctness of the generated patch is evaluated primarily through automated testing. Specifically, we execute the unit tests and regression tests associated with the repository. LetTdenote the set of unit and regression tests. Given a generated patchy, the reward is defined as follows. r edit (x, y) = I ∀t∈T , t(y) = pass ,(4) whereI[·]is the indicator function. The agent receives a positive reward if all tests pass, indicating that the edit resolves the intended issue without introducing regressions. This evaluation strategy reflects real-world software development practices and enforces func- tional correctness under execution, rather than relying on heuristic or textual similarity metrics. 3 Preprint Unit-Test Generation Given a target function or module and a natural language or im- plicit behavioral specification, the agent is tasked with generating unit tests that validate correctness and expose potential edge cases. To construct training instances, we start from open-source repositories with existing test suites. For each target function, we remove the original tests and ask the agent to regenerate them based on the function implementation and its documentation. A generated test suite is considered valid only if it satisfies two criteria: (1) all tests pass on the original, correct implementation, and (2) the tests successfully detect faults injected into the code. Letfdenote the target function andB( f )denote a set of buggy variants generated via LLM-based semantic mutation. The reward is defined as follows. r test (x, y) = I h y passes on f ∧ ∀ f ′ ∈B( f ), y fails on f ′ i , (5) Specifically, we use Kimi-K2-Thinking (Team et al., 2025b) to generate 16 semantically plausible buggy variants for each target function, and retain only those variants that are detected by the original (golden) unit tests before using them for reward computation. This design avoids reliance on raw coverage metrics, which can be misleading or insensitive to semantic errors, and instead directly evaluates the fault-detection capability of generated tests. Code Review Given a software development task specification—such as debugging, feature implementation, the agent performs code review by producing: (i) a natural language review summary describing potential issues or improvements, and (i) a binary judgment indicating whether the pull request fully address the stated problem. To construct review data, we generate pull requests using multiple independent coding agents (e.g., Claude Code (Anthropic, 2025), SWE-agent (Yang et al., 2024), OpenHands (Wang et al., 2025b)) and validate their correctness via automated testing. This yields triplets of the form⟨issue, pull request, correctness label⟩. During training, the agent’s binary judgment is compared against the correctness label. A positive reward is assigned if the judgment matches the ground truth, and a negative reward otherwise. Let z∈0, 1 denote the correctness label. Given the agent’s binary judgment ˆ z(y), the reward is defined as follows. r rev (x, y) = I ˆ z(y) = z ,(6) This formulation encourages the agent to reason about semantic correctness and complete- ness of code changes, rather than surface-level stylistic properties. Issue Reproduction Given an issue description and a codebase, the agent constructs a minimal executable script or command sequence that reproduces the reported issue. A reproduction script is considered successful if it satisfies two conditions: (1) the script triggers the reported failure on the original codebase, and (2) the failure no longer occurs after applying the corresponding ground-truth patch. Letℓ pre andℓ post denote the execution logs before and after patch application. The reward is defined as r repr (x, y) = I h failure(ℓ pre )∧ ¬failure(ℓ post ) i , (7) wherefailure(·)is determined by an LLM-based log judge (i.e., Kimi-K2-Thinking (Team et al., 2025b)). In practice, this judgment is well-suited for an LLM, since it reduces to comparing two execution logs and deciding whether the reported failure pattern appears before the patch but disappears after the patch. This skill emphasizes causal reasoning about program behavior, environment configuration, and failure conditions, which is critical for downstream debugging tasks. Unified Task Interface All atomic skills are formulated under a unified agent interface. For detailed prompt information, please refer to Appendix E. At each training episode, the agent observes a task-specific inputxand produces a structured outputy. Each skill 4 Preprint is associated with an automatic or semi-automatic evaluator that maps(x,y)to a scalar rewardr k (x,y). Under this unified formulation, training aims to maximize the expected reward across all atomic skills as follows. max θ E k∼ p(k), x∼D k , y∼π θ (·|x) r k (x, y) ,(8) wherep(k)denotes the sampling distribution over skills. This unified formulation provides shared representations and diverse, robust rewards, therefore enables joint optimization across heterogeneous skills while maintaining clear, skill-specific supervision signals. 2.2 Joint Reinforcement Learning We train the coding agent via joint reinforcement learning over all atomic skills, using a single shared policy and a unified optimization objective. Figure 3 illustrates the overall training architecture. Agentic RL FormulationWe adopt an agentic reinforcement learning paradigm, where a single policyπ θ interacts with a sandboxed execution environment through tool calls. At each episode, a task instanceτ = (k,x,c)is sampled from the skills buffer, wherekdenotes the atomic skill type. Conditioned on the task inputx, the agent produces a sequence of actions by invoking a restricted set of tools, includingbashcommands andstrreplace operations on the file system. The episode terminates when the agent outputs a final structured result, which is evaluated to produce a scalar reward r k (x, y). Unified Trajectory SamplingTo enable joint training, we do not separate rollouts by skill. Instead, rollout workers sample tasks from a unified skills buffer that mixes task instances from all atomic skills. Each rollout thus corresponds to a trajectory as follows. γ = (x, a 1 , a 2 , . . . , a T , y, r k ),(9) where the action sequencea t may involve tool invocations and intermediate observations. All trajectories, regardless of skill type, are stored in a unified trajectory buffer and contribute jointly to policy optimization. Joint Optimization ObjectiveThe trainer workers optimize a single shared policy using rewards aggregated across all atomic skills. The training objective is formulated as follows. max θ E k∼ p(k), x∼D k , y∼π θ (·|x) [ r k (x, y) ] ,(10) wherep(k)denotes the task sampling distribution over skills. No skill-specific heads or separate optimizers are introduced; all skills share the same policy parameters and optimization dynamics. Group-based Relative Policy Optimization We employ Group-based Relative Policy Optimization (GRPO) Shao et al. (2024) to stabilize training and improve sample efficiency. For each task inputx, rollout workers generate a group of candidate outputsy i N i=1 by sampling from the current policy. The corresponding rewardsr i are normalized within the group to compute relative advantages as follows. A i = r i − 1 N N ∑ j=1 r j ,(11) L GRPO (θ) = E " N ∑ i=1 A i log π θ (y i | x) # ,(12) optionally regularized by a KL-divergence term to the supervised initialization. This relative formulation mitigates reward scale mismatch across skills and reduces sensitivity to noisy absolute rewards. 5 Preprint Table 1: Performance Improvement (Avg@3) on 5 Atomics Skills. Bold andunderlined values denote the best and runner-up. ModelsCode LocationCode EditingIssue ReproduceUnit Test GenerationCode Review GLM-4.5-Air Team et al. (2025a)0.6660.5560.5550.4230.536 GLM-4.5-Air-Base + SFT0.6650.4580.5420.3590.563 GLM-4.5-Air-Base + SFT + RL0.7120.6110.6050.4720.622 Table 2: Generalization Performance (Avg@3) on 5 Composite Tasks. Bold andunderlined values denote the best and runner-up. ModelsSWE-bench Verified SWE-bench Multilingual Terminal Bench 2.0 Code Refactoring SEC-bench GLM-4.5-Air Team et al. (2025a)0.5590.3580.1870.1590.163 GLM-4.5-Air-Base + SFT0.5070.3000.1510.1460.136 GLM-4.5-Air-Base + SFT + RL0.5850.3890.1820.1710.169 2.3 Infrastructure Optimization Joint reinforcement learning over heterogeneous atomic skills imposes stringent require- ments on execution isolation, scalability, and throughput. To support large-scale agentic RL with frequent tool calls and execution-based evaluation, we optimize the training infrastruc- ture along several key dimensions. Sandboxed Execution Environment We build a unified sandbox for executing all agent interactions, including tool calls, test execution, and reward evaluation. It is deployed on Kubernetes The Kubernetes Authors (2026) over hybrid cloud clusters, ensuring strong isolation and fault containment at scale. Each instance follows an ephemeral lifecycle (create- on-demand, destroy-after-use), preventing state leakage across episodes and improving reward reproducibility. The system supports 10,000+ concurrent sandboxes with low startup latency. To prevent reward hacking, we restrict agent privileges by disabling network access and removing.githistory, blocking external retrieval and leakage of ground-truth patches. We further adopt a sidecar container architecture with 25,000+ pre-built Docker images, enabling diverse environments (e.g., unit testing, regression testing, issue reproduction) within a unified training loop. All atomic skills are evaluated inside the sandbox for consistent, execution-grounded rewards. Minimal Tool Scaffolding We deliberately restrict the agent’s action space to a minimal set of deterministic tools:bashfor command execution andstrreplacefor file editing. Despite its simplicity, this toolset is sufficient to express all atomic skills considered in this work. This design reduces action-space complexity and stabilizes reinforcement learning by avoiding brittle or overlapping tool abstractions. Moreover, using the same tool interface across all skills enforces consistent interaction patterns, which facilitates parameter sharing and positive transfer during training. Decoupled Rollout and Training WorkersTo scale joint RL efficiently, we decouple rollout generation from policy optimization. Rollout workers asynchronously sample tasks from the unified skills buffer and execute agent trajectories in the sandbox. The resulting trajectories and rewards are streamed to trainer workers, which perform batched policy updates using GRPO. This decoupling enables high-throughput data collection while maintaining stable and synchronized policy optimization. It also allows heterogeneous atomic skills with varying execution costs to coexist within the same training pipeline without blocking one another. 6 Preprint Atomic Skills OOD Tasks 0255075100 0.65 0.66 0.67 0.68 0.69 0.70 0.71 0.72 Avg@3 Location 0255075100 0.40 0.45 0.50 0.55 0.60 0.65 Editing 0255075100 0.53 0.54 0.55 0.56 0.57 0.58 0.59 0.60 0.61 0.62 Reproduce 0255075100 0.34 0.36 0.38 0.40 0.42 0.44 0.46 0.48 0.50 Unit Test 0255075100 0.50 0.55 0.60 0.65 0.70 Code Review 0255075100 0.50 0.52 0.54 0.56 0.58 0.60 0.62 Average 0255075100 RL Iteration 0.48 0.50 0.52 0.54 0.56 0.58 0.60 Avg@3 SWE-Verified 0255075100 RL Iteration 0.28 0.30 0.32 0.34 0.36 0.38 0.40 0.42 Multilingual 0255075100 RL Iteration 0.14 0.15 0.16 0.17 0.18 0.19 0.20 0.21 0.22 Terminal 0255075100 RL Iteration 0.12 0.13 0.14 0.15 0.16 0.17 0.18 Refactoring 0255075100 RL Iteration 0.12 0.13 0.14 0.15 0.16 0.17 0.18 SecBench 0255075100 RL Iteration 0.24 0.25 0.26 0.27 0.28 0.29 0.30 0.31 Average RL Training Progress: Avg@3 Performance (Atomic Skills vs OOD Tasks) Figure 4: Performance Curve of Joint RL across 5 Atomic Skills. The first and second rows denote the performance of atomic skills and the performance of composite coding tasks, respectively, during the joint RL training. 3 Experiments 3.1 Evaluation Protocol and Metrics. All methods start from the same SFT-initialized model trained only on atomic-skill data. Our base model is GLM-4.5-Air-Base (Team et al., 2025a), which adopts 106B total parameters with 12B active parameters. The GLM-4.5 family is designed for complex coding and agentic problem solving. The SFT initialization is obtained by sft on 1,500 judge-verified trajectories (300 per atomic skill), where the raw trajectories are generated bygpt-oss-120b(Agarwal et al., 2025). We periodically evaluate during RL training and report learning curves. For all tasks, we report the average performance over three runs (Avg@3). For OOD composite benchmarks, we use each benchmark’s standard success metric (e.g., verified pass rate for bug-fixing). OOD Composite Benchmarks. We consider five OOD benchmarks that were not used as RL objectives: (1) SWE-bench Verified OpenAI (2024): Python bug-fixingsFixing tasks with verified correctness; (2) SWE-bench Multilingual Yang et al. (2025b): bug-fixing tasks spanning multiple programming languages; (3) Terminal-Bench Merrill et al. (2026):bash- only tasks covering software engineering, MLE, development, and security scenarios; (4) SEC-Bench Lee et al. (2025b): security tasks that test whether agents can reproduce known vulnerabilities and write proof-of-concept (PoC) exploits under sandbox constraints; (5) Code Refactoring (ours): a refactoring benchmark constructed from real commits. We manually select refactoring-related commits, verify that the change and associated tests are complete, and curate 300 refactoring tasks. Each task provides a refactoring requirement and requires the agent to modify code accordingly; correctness is verified by a dedicated test suite we wrote for the benchmark. 3.2 Performance We report overall performance at three stages to quantify. Concretely, we evaluate: (a) a publicly available, thinking model GLM-4.5-Air (Team et al., 2025a) as a strong reference for complex instruction following, coding, and agentic tasks; (b) our Base-SFT model, obtained by supervised fine-tuning the GLM-4.5-Base on atomic-skill data only; and (c) Base-SFT-RL, obtained by further applying joint RL over atomic skills on our Base-SFT model. We do not directly evaluate the raw base model, since without post-training (e.g., instruction tuning and alignment), it typically exhibits weak instruction following and does not provide a meaningful agentic baseline. We evaluate on ten tasks in total: five atomic skills (Code Location, Code Editing, Issue Reproduce, Unit Test Generation, Code Review) and five OOD composite benchmarks (SWE-bench Verified, SWE-bench Multilingual, Terminal-Bench, Code Refactoring, SEC-Bench). Tables 1 and 2 report Avg@3 for the atomic skills and OOD tasks show, respectively. 7 Preprint Atomic Skills OOD Tasks SFT50607080 0.66 0.67 0.68 0.69 0.70 0.71 Avg@3 Location SFT50607080 0.40 0.45 0.50 0.55 0.60 Editing SFT50607080 0.52 0.54 0.56 0.58 0.60 0.62 Reproduce SFT50607080 0.34 0.36 0.38 0.40 0.42 0.44 0.46 Unit Test SFT50607080 0.50 0.55 0.60 0.65 0.70 Code Review SFT50607080 0.50 0.52 0.54 0.56 0.58 0.60 0.62 Average SFT50607080 RL Iteration 0.50 0.52 0.54 0.56 0.58 Avg@3 SWE-Verified SFT50607080 RL Iteration 0.28 0.30 0.32 0.34 0.36 0.38 0.40 0.42 Multilingual SFT50607080 RL Iteration 0.12 0.14 0.16 0.18 0.20 Terminal SFT50607080 RL Iteration 0.13 0.14 0.15 0.16 0.17 0.18 Refactoring SFT50607080 RL Iteration 0.13 0.14 0.15 0.16 0.17 SecBench SFT50607080 RL Iteration 0.24 0.25 0.26 0.27 0.28 0.29 0.30 Average Per-Task Learning Curves: Skills-Joint RL vs Single-Skill RL Editing-Only RLVerified-Only RLSkills-Joint RL Figure 5: Single-skill RL vs. Joint-skill RL. We conduct ablation studies by performing RL on all 5 skills and RL on a single skill, e.g., coding editing. The first and second rows denote the performance of atomic skills and composite coding tasks, respectively. Results and Analysis. Joint atomic-skills RL improves all atomic skills over Base-SFT (e.g., Location: 0.665→0.712; Editing: 0.458→0.611; Unit Test: 0.359→0.472), demonstrating effective optimization of heterogeneous capabilities under a shared policy. These gains transfer to OOD composite benchmarks, with consistent improvements on SWE- bench Verified (0.507→0.585), SWE-bench Multilingual (0.300→0.389), Terminal-Bench, Refactoring, and SEC-Bench. Compared to GLM-4.5-Air (Team et al., 2025a), our model is competitive or stronger on most tasks, outperforming on multiple OOD benchmarks while slightly trailing on Terminal- Bench. Overall, joint RL yields higher Avg@3 than Base-SFT (0.452 vs. 0.383) and GLM-4.5-Air (0.452 vs. 0.416), indicating a net capability gain. 3.3 Performance on atomic skills and OOD tasks. Figure 4 shows joint RL training curves on atomic skills (top) and OOD composite bench- marks (bottom). We observe three patterns: (1) all atomic skills improve monotonically from SFT, indicating a shared policy can optimize heterogeneous capabilities without trade-offs; (2) the averaged atomic score increases steadily, suggesting positive transfer; (3) gains consistently transfer to all OOD benchmarks, demonstrating compositional generaliza- tion—improving reusable atomic skills leads to better performance on unseen composite tasks. 3.4 Joint RL vs. single-task RL To isolate whether the gains stem from joint optimization rather than simply applying RL, we compare joint atomic-skills RL to single-task RL baselines on (i) a representative atomic skill and (i) a representative composite task. Concretely, we train (a) editing-only RL (optimizing only the code editing reward), (b) verified-only RL (optimizing only SWE-bench Verified, i.e., bug fixing), and (c) joint atomic-skills RL. Figure 5 reports per-task learning curves across RL iterations. Two findings stand out. First, specialization exhibits weaker cross-capability improvements. While verified-only RL focuses on the bug-fixing objective, its performance is comparatively lower on several other capabilities that are not directly trained, including refactoring and multiple atomic skills such as issue reproduction and code review. In contrast, joint atomic- skills RL achieves greater and more consistent improvements across most atomic skills and across OOD benchmarks, indicating that joint training improves the underlying composi- tional building blocks rather than overfitting to a single benchmark distribution. Overall, joint atomic-skills RL provides broader capability gains and better generalization across diverse unseen tasks. Second, specializing on a single composite benchmark can match 8 Preprint 020406080100 RL Iteration 0.35 0.40 0.45 0.50 0.55 0.60 Performance Reproduce Performance Avg Steps 020406080100 RL Iteration 0.35 0.40 0.45 0.50 0.55 0.60 Location 020406080100 RL Iteration 0.350 0.375 0.400 0.425 0.450 0.475 0.500 0.525 0.550 Editing 020406080100 RL Iteration 0.40 0.45 0.50 0.55 0.60 0.65 Unit Test 020406080100 RL Iteration 0.55 0.60 0.65 0.70 0.75 0.80 Code Review 20 22 24 26 28 30 32 34 Avg Steps 25.0 27.5 30.0 32.5 35.0 37.5 40.0 42.5 45.0 55 60 65 70 75 80 85 45.0 47.5 50.0 52.5 55.0 57.5 60.0 62.5 65.0 20 25 30 35 40 45 50 55 Figure 6: Training Dynamics. Performance vs Steps across Atomic Skills. in-domain performance: verified-only RL reaches essentially the same SWE-bench Verified score as joint atomic-skills RL at later training. This suggests that direct optimization on a target benchmark can yield competitive in-domain gains, as expected from task-specific RL. 3.5 Training Dynamics: Performance & Tool-Use Steps We analyze training dynamics of joint atomic-skills RL using two signals: Pass@1 and average environment steps. Across skills, performance generally improves with training, while step usage shows skill-dependent patterns. For Location, Editing, and Unit Test, both performance and steps increase, indicating greater reliance on tool-mediated interaction. Issue Reproduction exhibits higher variance in both metrics, reflecting sensitivity to execution context and evaluation noise. Code Review shows non-monotonic step usage (increase–decrease–increase) with overall performance gains, suggesting a shift from early exploration to mid-stage efficiency and late-stage refinement. 4 Related Work 4.1 Agentic RL Agentic RL transforms LLMs from passive generators into tool-using agents that interact with complex environments Yao et al. (2022); Zhang et al. (2025); Team et al. (2025b); Yang et al. (2025a); Z.ai (2025); OpenAI (2025b); Anthropic (2025a); Google (2025). Recent work leverages RL to train such agents end-to-end across domains including software engineering, GUI interaction, and web search Yang et al. (2024); Wei et al. (2025); Wang et al. (2025b;a); Lai et al. (2025); Shi et al. (2025); Jin et al. (2025); Zheng et al. (2025); Song et al. (2025), demonstrating strong specialization and generalization. These agents rely on frequent tool use, placing demands on long-context modeling and memory, motivating advances in context management and memory-augmented architectures Packer et al. (2024); Wang et al. (2024); Ye et al. (2025); Liu et al. (2025). While prior joint RL studies combine heterogeneous tasks across domains, sub-task-level joint training—particularly for coding agents—remains underexplored Ma et al. (2025c). 5 Conclusion We propose an atomic-skill-based scaling paradigm for LLM coding agents, instead of directly optimizing composite benchmarks. We define five atomic skills—code localization, editing, unit-test generation, issue reproduction, and code review—under a unified interface with structured outputs and sandboxed, execution-grounded rewards. We train a single shared policy via joint RL over mixed skills, enabling stable optimization across heteroge- neous signals. Joint training improves all atomic skills without negative interference and generalizes to unseen composite tasks (e.g., bug fixing, terminal tasks, refactoring, and security). Compared to single-task RL, it preserves in-domain performance while enhancing broader capabilities, demonstrating a favorable specialization–generalization trade-off. We hope this motivates scaling reusable atomic skills and expanding the skill library for more comprehensive software engineering workflows. 9 Preprint References Sandhini Agarwal, Lama Ahmad, Jason Ai, Sam Altman, Andy Applebaum, Edwin Arbus, Rahul K Arora, Yu Bai, Bowen Baker, Haiming Bao, et al. gpt-oss-120b & gpt-oss-20b model card. arXiv preprint arXiv:2508.10925, 2025. Anthropic. Claude Opus 4.5: Blogs, 2025a. URLhttps://w.anthropic.com/news/ claude-opus-4-5. Anthropic. Claude Code: Blogs, 2025b. URLhttps://platform.claude.com/docs/en/docs/ claude-code/overview. Anthropic.Claudecode:Bestpracticesforagenticcoding. https://w.anthropic.com/engineering/claude-code-best-practices, 2025. Jun Shern Chan, Neil Chowdhury, Oliver Jaffe, James Aung, Dane Sherburn, Evan Mays, Giulio Starace, Kevin Liu, Leon Maksin, Tejal Patwardhan, et al. Mle-bench: Evaluating machine learning agents on machine learning engineering. arXiv preprint arXiv:2410.07095, 2024. Zhaoling Chen, Xiangru Tang, Gangda Deng, Fang Wu, Jialong Wu, Zhiwei Jiang, Viktor Prasanna, Arman Cohan, and Xingyao Wang. Locagent: Graph-guided llm agents for code localization, 2025. URL https://arxiv.org/abs/2503.09089. Google Deepmind. Gemini deep research. https://gemini.google/overview/deep-research/, 2025. DeepSeek-AI, Daya Guo, Dejian Yang, Haowei Zhang, Junxiao Song, Peiyi Wang, Qihao Zhu, Runxin Xu, Ruoyu Zhang, Shirong Ma, Xiao Bi, Xiaokang Zhang, Xingkai Yu, Yu Wu, Z. F. Wu, Zhibin Gou, Zhihong Shao, Zhuoshu Li, Ziyi Gao, Aixin Liu, Bing Xue, Bingxuan Wang, Bochao Wu, Bei Feng, Chengda Lu, Chenggang Zhao, Chengqi Deng, Chenyu Zhang, Chong Ruan, Damai Dai, Deli Chen, Dongjie Ji, Erhang Li, Fangyun Lin, Fucong Dai, Fuli Luo, Guangbo Hao, Guanting Chen, Guowei Li, H. Zhang, Han Bao, Hanwei Xu, Haocheng Wang, Honghui Ding, Huajian Xin, Huazuo Gao, Hui Qu, Hui Li, Jianzhong Guo, Jiashi Li, Jiawei Wang, Jingchang Chen, Jingyang Yuan, Junjie Qiu, Junlong Li, J. L. Cai, Jiaqi Ni, Jian Liang, Jin Chen, Kai Dong, Kai Hu, Kaige Gao, Kang Guan, Kexin Huang, Kuai Yu, Lean Wang, Lecong Zhang, Liang Zhao, Litong Wang, Liyue Zhang, Lei Xu, Leyi Xia, Mingchuan Zhang, Minghua Zhang, Minghui Tang, Meng Li, Miaojun Wang, Mingming Li, Ning Tian, Panpan Huang, Peng Zhang, Qiancheng Wang, Qinyu Chen, Qiushi Du, Ruiqi Ge, Ruisong Zhang, Ruizhe Pan, Runji Wang, R. J. Chen, R. L. Jin, Ruyi Chen, Shanghao Lu, Shangyan Zhou, Shanhuang Chen, Shengfeng Ye, Shiyu Wang, Shuiping Yu, Shunfeng Zhou, Shuting Pan, S. S. Li, Shuang Zhou, Shaoqing Wu, Shengfeng Ye, Tao Yun, Tian Pei, Tianyu Sun, T. Wang, Wangding Zeng, Wanjia Zhao, Wen Liu, Wenfeng Liang, Wenjun Gao, Wenqin Yu, Wentao Zhang, W. L. Xiao, Wei An, Xiaodong Liu, Xiaohan Wang, Xiaokang Chen, Xiaotao Nie, Xin Cheng, Xin Liu, Xin Xie, Xingchao Liu, Xinyu Yang, Xinyuan Li, Xuecheng Su, Xuheng Lin, X. Q. Li, Xiangyue Jin, Xiaojin Shen, Xiaosha Chen, Xiaowen Sun, Xiaoxiang Wang, Xinnan Song, Xinyi Zhou, Xianzu Wang, Xinxia Shan, Y. K. Li, Y. Q. Wang, Y. X. Wei, Yang Zhang, Yanhong Xu, Yao Li, Yao Zhao, Yaofeng Sun, Yaohui Wang, Yi Yu, Yichao Zhang, Yifan Shi, Yiliang Xiong, Ying He, Yishi Piao, Yisong Wang, Yixuan Tan, Yiyang Ma, Yiyuan Liu, Yongqiang Guo, Yuan Ou, Yuduan Wang, Yue Gong, Yuheng Zou, Yujia He, Yunfan Xiong, Yuxiang Luo, Yuxiang You, Yuxuan Liu, Yuyang Zhou, Y. X. Zhu, Yanhong Xu, Yanping Huang, Yaohui Li, Yi Zheng, Yuchen Zhu, Yunxian Ma, Ying Tang, Yukun Zha, Yuting Yan, Z. Z. Ren, Zehui Ren, Zhangli Sha, Zhe Fu, Zhean Xu, Zhenda Xie, Zhengyan Zhang, Zhewen Hao, Zhicheng Ma, Zhigang Yan, Zhiyu Wu, Zihui Gu, Zijia Zhu, Zijun Liu, Zilin Li, Ziwei Xie, Ziyang Song, Zizheng Pan, Zhen Huang, Zhipeng Xu, Zhongyu Zhang, and Zhen Zhang. Deepseek-r1: Incentivizing reasoning capability in llms via reinforcement learning, 2026. URL https://arxiv.org/abs/2501.12948. Yaxin Du, Yuzhu Cai, Yifan Zhou, Cheng Wang, Yu Qian, Xianghe Pang, Qian Liu, Yue Hu, and Siheng Chen. Swe-dev: Evaluating and training autonomous feature-driven software development, 2025. URL https://arxiv.org/abs/2505.16975. 10 Preprint GitHub. Github Copilot Code Review, 2025. URLhttps://docs.github.com/en/copilot/ how-tos/use-copilot-agents/request-a-code-review/use-code-review. Google. Gemini 3: Blogs, 2025. URL https://deepmind.google/models/gemini/. Lianghong Guo, Yanlin Wang, Caihua Li, Pengyu Yang, Jiachi Chen, Wei Tao, Yingtian Zou, Duyu Tang, and Zibin Zheng. Swe-factory: Your automated factory for issue resolution training data and evaluation benchmarks. arXiv preprint arXiv:2506.10954, 2025. Dong Huang, Jianbo Dai, Han Weng, Puzhen Wu, Yuhao Qing, Heming Cui, Zhijiang Guo, and Jie M. Zhang. Effilearner: Enhancing efficiency of generated code via self- optimization, 2025. URL https://arxiv.org/abs/2405.15189. 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. 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?, 2024. URL https://arxiv.org/abs/2310.06770. Bowen Jin, Hansi Zeng, Zhenrui Yue, Jinsung Yoon, Sercan Arik, Dong Wang, Hamed Zamani, and Jiawei Han. Search-r1: Training llms to reason and leverage search engines with reinforcement learning, 2025. URL https://arxiv.org/abs/2503.09516. Hanyu Lai, Xiao Liu, Yanxiao Zhao, Han Xu, Hanchen Zhang, Bohao Jing, Yanyu Ren, Shuntian Yao, Yuxiao Dong, and Jie Tang. Computerrl: Scaling end-to-end online reinforce- ment learning for computer use agents, 2025. URL https://arxiv.org/abs/2508.14040. Dongjun Lee, Changho Hwang, and Kimin Lee. Learning to generate unit test via adversarial reinforcement learning, 2025a. URL https://arxiv.org/abs/2508.21107. Hwiwon Lee, Ziqi Zhang, Hanxiao Lu, and Lingming Zhang. Sec-bench: Automated benchmarking of llm agents on real-world software security tasks.arXiv preprint arXiv:2506.11791, 2025b. Shukai Liu, Jian Yang, Bo Jiang, Yizhi Li, Jinyang Guo, Xianglong Liu, and Bryan Dai. Context as a tool: Context management for long-horizon swe-agents, 2025. URLhttps: //arxiv.org/abs/2512.22087. Yingwei Ma, Rongyu Cao, Yongchang Cao, Yue Zhang, Jue Chen, Yibo Liu, Yuchen Liu, Binhua Li, Fei Huang, and Yongbin Li. Lingma swe-gpt: An open development- process-centric language model for automated software improvement. arXiv preprint arXiv:2411.00622, 2024. Yingwei Ma, Yongbin Li, Yihong Dong, Xue Jiang, Rongyu Cao, Jue Chen, Fei Huang, and Binhua Li. Thinking longer, not larger: Enhancing software engineering agents via scaling test-time compute, 2025a. URL https://arxiv.org/abs/2503.23803. Yingwei Ma, Qingping Yang, Rongyu Cao, Binhua Li, Fei Huang, and Yongbin Li. Alibaba lingmaagent: Improving automated issue resolution via comprehensive repository explo- ration. In Proceedings of the 33rd ACM International Conference on the Foundations of Software Engineering, p. 238–249, 2025b. Zexiong Ma, Chao Peng, Pengfei Gao, Xiangxin Meng, Yanzhen Zou, and Bing Xie. Sorft: Issue resolving with subtask-oriented reinforced fine-tuning, 2025c. URLhttps://arxiv. org/abs/2502.20127. Zeyao Ma, Xiaokang Zhang, Jing Zhang, Jifan Yu, Sijia Luo, and Jie Tang. Dynamic scaling of unit tests for code reward modeling, 2025d. URLhttps://arxiv.org/abs/2501.01054. Nat McAleese, Rai Michael Pokorny, Juan Felipe Ceron Uribe, Evgenia Nitishinskaya, Maja Trebacz, and Jan Leike. Llm critics help catch llm bugs, 2024. URLhttps://arxiv.org/ abs/2407.00215. 11 Preprint Mike A. Merrill, Alexander G. Shaw, Nicholas Carlini, Boxuan Li, Harsh Raj, Ivan Bercovich, Lin Shi, Jeong Yeon Shin, Thomas Walshe, E. Kelly Buchanan, Junhong Shen, Guang- hao Ye, Haowei Lin, Jason Poulos, Maoyu Wang, Marianna Nezhurina, Jenia Jitsev, Di Lu, Orfeas Menis Mastromichalakis, Zhiwei Xu, Zizhao Chen, Yue Liu, Robert Zhang, Leon Liangyu Chen, Anurag Kashyap, Jan-Lucas Uslu, Jeffrey Li, Jianbo Wu, Minghao Yan, Song Bian, Vedang Sharma, Ke Sun, Steven Dillmann, Akshay Anand, Andrew Lanpouthakoun, Bardia Koopah, Changran Hu, Etash Guha, Gabriel H. S. Dreiman, Jiacheng Zhu, Karl Krauth, Li Zhong, Niklas Muennighoff, Robert Amanfu, Shangyin Tan, Shreyas Pimpalgaonkar, Tushar Aggarwal, Xiangning Lin, Xin Lan, Xuandong Zhao, Yiqing Liang, Yuanli Wang, Zilong Wang, Changzhi Zhou, David Heineman, Hange Liu, Harsh Trivedi, John Yang, Junhong Lin, Manish Shetty, Michael Yang, Nabil Omi, Negin Raoof, Shanda Li, Terry Yue Zhuo, Wuwei Lin, Yiwei Dai, Yuxin Wang, Wenhao Chai, Shang Zhou, Dariush Wahdany, Ziyu She, Jiaming Hu, Zhikang Dong, Yuxuan Zhu, Sasha Cui, Ahson Saiyed, Arinbj ̈ orn Kolbeinsson, Jesse Hu, Christopher Michael Rytting, Ryan Marten, Yixin Wang, Alex Dimakis, Andy Konwinski, and Ludwig Schmidt. Terminal-bench: Benchmarking agents on hard, realistic tasks in command line interfaces, 2026. URL https://arxiv.org/abs/2601.11868. OpenAI. Introducing swe-bench verified. https://openai.com/index/introducing-swe-bench- verified/, 2024. OpenAI. Introducing chatgpt. https://openai.com/index/chatgpt/, 2025. OpenAI. OpenAI Codex, 2025a. URL https://chatgpt.com/codex. OpenAI.GPT-5.2:Blogs, 2025b.URLhttps://openai.com/zh-Hans-CN/index/ introducing-gpt-5-2/. Charles Packer, Sarah Wooders, Kevin Lin, Vivian Fang, Shishir G. Patil, Ion Stoica, and Joseph E. Gonzalez. Memgpt: Towards llms as operating systems, 2024. URLhttps: //arxiv.org/abs/2310.08560. Revanth Gangi Reddy, Ye Liu, Wenting Zhao, JaeHyeok Doo, Tarun Suresh, Daniel Lee, Caiming Xiong, Yingbo Zhou, Semih Yavuz, and Shafiq Joty. Swerank+: Multilingual, multi-turn code ranking for software issue localization, 2025. URLhttps://arxiv.org/ abs/2512.20482. Xiaoxue Ren, Jun Wan, Yun Peng, Zhongxin Liu, Ming Liang, Dajun Chen, Wei Jiang, and Yong Li. Peace: Towards efficient project-level efficiency optimization via hybrid code editing, 2025. URL https://arxiv.org/abs/2510.17142. Zhihong Shao, Peiyi Wang, Qihao Zhu, Runxin Xu, Junxiao Song, Xiao Bi, Haowei Zhang, Mingchuan Zhang, Y. K. Li, Y. Wu, and Daya Guo. Deepseekmath: Pushing the limits of mathematical reasoning in open language models, 2024. URLhttps://arxiv.org/abs/ 2402.03300. Yucheng Shi, Wenhao Yu, Zaitang Li, Yonglin Wang, Hongming Zhang, Ninghao Liu, Haitao Mi, and Dong Yu. Mobilegui-rl: Advancing mobile gui agent through reinforcement learning in online environment, 2025. URL https://arxiv.org/abs/2507.05720. KaShun Shum, Binyuan Hui, Jiawei Chen, Lei Zhang, X. W., Jiaxi Yang, Yuzhen Huang, Junyang Lin, and Junxian He. Swe-rm: Execution-free feedback for software engineering agents, 2025. URL https://arxiv.org/abs/2512.21919. Huatong Song, Jinhao Jiang, Yingqian Min, Jie Chen, Zhipeng Chen, Wayne Xin Zhao, Lei Fang, and Ji-Rong Wen. R1-searcher: Incentivizing the search capability in llms via reinforcement learning, 2025. URL https://arxiv.org/abs/2503.05592. Giulio Starace, Oliver Jaffe, Dane Sherburn, James Aung, Jun Shern Chan, Leon Maksin, Rachel Dias, Evan Mays, Benjamin Kinsella, Wyatt Thompson, et al. Paperbench: Evalu- ating ai’s ability to replicate ai research. arXiv preprint arXiv:2504.01848, 2025. 12 Preprint 5 Team, Aohan Zeng, Xin Lv, Qinkai Zheng, Zhenyu Hou, Bin Chen, Chengxing Xie, Cunxiang Wang, Da Yin, Hao Zeng, Jiajie Zhang, Kedong Wang, Lucen Zhong, Mingdao Liu, Rui Lu, Shulin Cao, Xiaohan Zhang, Xuancheng Huang, Yao Wei, Yean Cheng, Yifan An, Yilin Niu, Yuanhao Wen, Yushi Bai, Zhengxiao Du, Zihan Wang, Zilin Zhu, Bohan Zhang, Bosi Wen, Bowen Wu, Bowen Xu, Can Huang, Casey Zhao, Changpeng Cai, Chao Yu, Chen Li, Chendi Ge, Chenghua Huang, Chenhui Zhang, Chenxi Xu, Chenzheng Zhu, Chuang Li, Congfeng Yin, Daoyan Lin, Dayong Yang, Dazhi Jiang, Ding Ai, Erle Zhu, Fei Wang, Gengzheng Pan, Guo Wang, Hailong Sun, Haitao Li, Haiyang Li, Haiyi Hu, Hanyu Zhang, Hao Peng, Hao Tai, Haoke Zhang, Haoran Wang, Haoyu Yang, He Liu, He Zhao, Hongwei Liu, Hongxi Yan, Huan Liu, Huilong Chen, Ji Li, Jiajing Zhao, Jiamin Ren, Jian Jiao, Jiani Zhao, Jianyang Yan, Jiaqi Wang, Jiayi Gui, Jiayue Zhao, Jie Liu, Jijie Li, Jing Li, Jing Lu, Jingsen Wang, Jingwei Yuan, Jingxuan Li, Jingzhao Du, Jinhua Du, Jinxin Liu, Junkai Zhi, Junli Gao, Ke Wang, Lekang Yang, Liang Xu, Lin Fan, Lindong Wu, Lintao Ding, Lu Wang, Man Zhang, Minghao Li, Minghuan Xu, Mingming Zhao, Mingshu Zhai, Pengfan Du, Qian Dong, Shangde Lei, Shangqing Tu, Shangtong Yang, Shaoyou Lu, Shijie Li, Shuang Li, Shuang-Li, Shuxun Yang, Sibo Yi, Tianshu Yu, Wei Tian, Weihan Wang, Wenbo Yu, Weng Lam Tam, Wenjie Liang, Wentao Liu, Xiao Wang, Xiaohan Jia, Xiaotao Gu, Xiaoying Ling, Xin Wang, Xing Fan, Xingru Pan, Xinyuan Zhang, Xinze Zhang, Xiuqing Fu, Xunkai Zhang, Yabo Xu, Yandong Wu, Yida Lu, Yidong Wang, Yilin Zhou, Yiming Pan, Ying Zhang, Yingli Wang, Yingru Li, Yinpei Su, Yipeng Geng, Yitong Zhu, Yongkun Yang, Yuhang Li, Yuhao Wu, Yujiang Li, Yunan Liu, Yunqing Wang, Yuntao Li, Yuxuan Zhang, Zezhen Liu, Zhen Yang, Zhengda Zhou, Zhongpei Qiao, Zhuoer Feng, Zhuorui Liu, Zichen Zhang, Zihan Wang, Zijun Yao, Zikang Wang, Ziqiang Liu, Ziwei Chai, Zixuan Li, Zuodong Zhao, Wenguang Chen, Jidong Zhai, Bin Xu, Minlie Huang, Hongning Wang, Juanzi Li, Yuxiao Dong, and Jie Tang. Glm-4.5: Agentic, reasoning, and coding (arc) foundation models, 2025a. URL https://arxiv.org/abs/2508.06471. Kimi Team, Yifan Bai, Yiping Bao, Guanduo Chen, Jiahao Chen, Ningxin Chen, Ruijue Chen, Yanru Chen, Yuankun Chen, Yutian Chen, Zhuofu Chen, Jialei Cui, Hao Ding, Mengnan Dong, Angang Du, Chenzhuang Du, Dikang Du, Yulun Du, Yu Fan, Yichen Feng, Kelin Fu, Bofei Gao, Hongcheng Gao, Peizhong Gao, Tong Gao, Xinran Gu, Longyu Guan, Haiqing Guo, Jianhang Guo, Hao Hu, Xiaoru Hao, Tianhong He, Weiran He, Wenyang He, Chao Hong, Yangyang Hu, Zhenxing Hu, Weixiao Huang, Zhiqi Huang, Zihao Huang, Tao Jiang, Zhejun Jiang, Xinyi Jin, Yongsheng Kang, Guokun Lai, Cheng Li, Fang Li, Haoyang Li, Ming Li, Wentao Li, Yanhao Li, Yiwei Li, Zhaowei Li, Zheming Li, Hongzhan Lin, Xiaohan Lin, Zongyu Lin, Chengyin Liu, Chenyu Liu, Hongzhang Liu, Jingyuan Liu, Junqi Liu, Liang Liu, Shaowei Liu, T. Y. Liu, Tianwei Liu, Weizhou Liu, Yangyang Liu, Yibo Liu, Yiping Liu, Yue Liu, Zhengying Liu, Enzhe Lu, Lijun Lu, Shengling Ma, Xinyu Ma, Yingwei Ma, Shaoguang Mao, Jie Mei, Xin Men, Yibo Miao, Siyuan Pan, Yebo Peng, Ruoyu Qin, Bowen Qu, Zeyu Shang, Lidong Shi, Shengyuan Shi, Feifan Song, Jianlin Su, Zhengyuan Su, Xinjie Sun, Flood Sung, Heyi Tang, Jiawen Tao, Qifeng Teng, Chensi Wang, Dinglu Wang, Feng Wang, Haiming Wang, Jianzhou Wang, Jiaxing Wang, Jinhong Wang, Shengjie Wang, Shuyi Wang, Yao Wang, Yejie Wang, Yiqin Wang, Yuxin Wang, Yuzhi Wang, Zhaoji Wang, Zhengtao Wang, Zhexu Wang, Chu Wei, Qianqian Wei, Wenhao Wu, Xingzhe Wu, Yuxin Wu, Chenjun Xiao, Xiaotong Xie, Weimin Xiong, Boyu Xu, Jing Xu, Jinjing Xu, L. H. Xu, Lin Xu, Suting Xu, Weixin Xu, Xinran Xu, Yangchuan Xu, Ziyao Xu, Junjie Yan, Yuzi Yan, Xiaofei Yang, Ying Yang, Zhen Yang, Zhilin Yang, Zonghan Yang, Haotian Yao, Xingcheng Yao, Wenjie Ye, Zhuorui Ye, Bohong Yin, Longhui Yu, Enming Yuan, Hongbang Yuan, Mengjie Yuan, Haobing Zhan, Dehao Zhang, Hao Zhang, Wanlu Zhang, Xiaobin Zhang, Yangkun Zhang, Yizhi Zhang, Yongting Zhang, Yu Zhang, Yutao Zhang, Yutong Zhang, Zheng Zhang, Haotian Zhao, Yikai Zhao, Huabin Zheng, Shaojie Zheng, Jianren Zhou, Xinyu Zhou, Zaida Zhou, Zhen Zhu, Weiyu Zhuang, and Xinxing Zu. Kimi k2: Open agentic intelligence, 2025b. URLhttps://arxiv.org/abs/2507.20534. Kimi Team, Angang Du, Bofei Gao, Bowei Xing, Changjiu Jiang, Cheng Chen, Cheng Li, Chenjun Xiao, Chenzhuang Du, Chonghua Liao, Chuning Tang, Congcong Wang, Dehao Zhang, Enming Yuan, Enzhe Lu, Fengxiang Tang, Flood Sung, Guangda Wei, Guokun Lai, Haiqing Guo, Han Zhu, Hao Ding, Hao Hu, Hao Yang, Hao Zhang, Haotian Yao, Haotian Zhao, Haoyu Lu, Haoze Li, Haozhen Yu, Hongcheng Gao, Huabin Zheng, Huan Yuan, Jia Chen, Jianhang Guo, Jianlin Su, Jianzhou Wang, Jie Zhao, Jin Zhang, Jingyuan Liu, 13 Preprint Junjie Yan, Junyan Wu, Lidong Shi, Ling Ye, Longhui Yu, Mengnan Dong, Neo Zhang, Ningchen Ma, Qiwei Pan, Qucheng Gong, Shaowei Liu, Shengling Ma, Shupeng Wei, Sihan Cao, Siying Huang, Tao Jiang, Weihao Gao, Weimin Xiong, Weiran He, Weixiao Huang, Weixin Xu, Wenhao Wu, Wenyang He, Xianghui Wei, Xianqing Jia, Xingzhe Wu, Xinran Xu, Xinxing Zu, Xinyu Zhou, Xuehai Pan, Y. Charles, Yang Li, Yangyang Hu, Yangyang Liu, Yanru Chen, Yejie Wang, Yibo Liu, Yidao Qin, Yifeng Liu, Ying Yang, Yiping Bao, Yulun Du, Yuxin Wu, Yuzhi Wang, Zaida Zhou, Zhaoji Wang, Zhaowei Li, Zhen Zhu, Zheng Zhang, Zhexu Wang, Zhilin Yang, Zhiqi Huang, Zihao Huang, Ziyao Xu, Zonghan Yang, and Zongyu Lin. Kimi k1.5: Scaling reinforcement learning with llms, 2025c. URL https://arxiv.org/abs/2501.12599. The Kubernetes Authors. Kubernetes: Production-grade container orchestration.https: //kubernetes.io/, 2026. Accessed: 2026-01-29. Haoming Wang, Haoyang Zou, Huatong Song, Jiazhan Feng, Junjie Fang, Junting Lu, Longxiang Liu, Qinyu Luo, Shihao Liang, Shijue Huang, Wanjun Zhong, Yining Ye, Yujia Qin, Yuwen Xiong, Yuxin Song, Zhiyong Wu, Aoyan Li, Bo Li, Chen Dun, Chong Liu, Daoguang Zan, Fuxing Leng, Hanbin Wang, Hao Yu, Haobin Chen, Hongyi Guo, Jing Su, Jingjia Huang, Kai Shen, Kaiyu Shi, Lin Yan, Peiyao Zhao, Pengfei Liu, Qinghao Ye, Renjie Zheng, Shulin Xin, Wayne Xin Zhao, Wen Heng, Wenhao Huang, Wenqian Wang, Xiaobo Qin, Yi Lin, Youbin Wu, Zehui Chen, Zihao Wang, Baoquan Zhong, Xinchun Zhang, Xujing Li, Yuanfan Li, Zhongkai Zhao, Chengquan Jiang, Faming Wu, Haotian Zhou, Jinlin Pang, Li Han, Qi Liu, Qianli Ma, Siyao Liu, Songhua Cai, Wenqi Fu, Xin Liu, Yaohui Wang, Zhi Zhang, Bo Zhou, Guoliang Li, Jiajun Shi, Jiale Yang, Jie Tang, Li Li, Qihua Han, Taoran Lu, Woyu Lin, Xiaokang Tong, Xinyao Li, Yichi Zhang, Yu Miao, Zhengxuan Jiang, Zili Li, Ziyuan Zhao, Chenxin Li, Dehua Ma, Feng Lin, Ge Zhang, Haihua Yang, Hangyu Guo, Hongda Zhu, Jiaheng Liu, Junda Du, Kai Cai, Kuanye Li, Lichen Yuan, Meilan Han, Minchao Wang, Shuyue Guo, Tianhao Cheng, Xiaobo Ma, Xiaojun Xiao, Xiaolong Huang, Xinjie Chen, Yidi Du, Yilin Chen, Yiwen Wang, Zhaojian Li, Zhenzhu Yang, Zhiyuan Zeng, Chaolin Jin, Chen Li, Hao Chen, Haoli Chen, Jian Chen, Qinghao Zhao, and Guang Shi. Ui-tars-2 technical report: Advancing gui agent with multi-turn reinforcement learning, 2025a. URL https://arxiv.org/abs/2509.02544. 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, 2025b. URLhttps: //arxiv.org/abs/2407.16741. Yu Wang, Yifan Gao, Xiusi Chen, Haoming Jiang, Shiyang Li, Jingfeng Yang, Qingyu Yin, Zheng Li, Xian Li, Bing Yin, Jingbo Shang, and Julian McAuley. Memoryllm: Towards self-updatable large language models, 2024. URL https://arxiv.org/abs/2402.04624. 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, 2025. URLhttps: //arxiv.org/abs/2502.18449. Junjielong Xu, Boyin Tan, Xiaoyuan Liu, Chao Peng, Pengfei Gao, and Pinjia He. Scalable supervising software agents with patch reasoner, 2025. URLhttps://arxiv.org/abs/ 2510.22775. An Yang, Anfeng Li, Baosong Yang, Beichen Zhang, Binyuan Hui, Bo Zheng, Bowen Yu, Chang Gao, Chengen Huang, Chenxu Lv, Chujie Zheng, Dayiheng Liu, Fan Zhou, Fei Huang, Feng Hu, Hao Ge, Haoran Wei, Huan Lin, Jialong Tang, Jian Yang, Jianhong Tu, Jianwei Zhang, Jianxin Yang, Jiaxi Yang, Jing Zhou, Jingren Zhou, Junyang Lin, Kai Dang, Keqin Bao, Kexin Yang, Le Yu, Lianghao Deng, Mei Li, Mingfeng Xue, Mingze Li, Pei Zhang, Peng Wang, Qin Zhu, Rui Men, Ruize Gao, Shixuan Liu, Shuang Luo, Tianhao Li, Tianyi Tang, Wenbiao Yin, Xingzhang Ren, Xinyu Wang, Xinyu Zhang, Xuancheng Ren, Yang Fan, Yang Su, Yichang Zhang, Yinger Zhang, Yu Wan, Yuqiong Liu, Zekun Wang, 14 Preprint Zeyu Cui, Zhenru Zhang, Zhipeng Zhou, and Zihan Qiu. Qwen3 technical report, 2025a. URL https://arxiv.org/abs/2505.09388. 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, 2024. URL https://arxiv.org/abs/2405.15793. 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, 2025b. URL https://arxiv.org/abs/2504.21798. Zonghan Yang, Shengjie Wang, Kelin Fu, Wenyang He, Weimin Xiong, Yibo Liu, Yibo Miao, Bofei Gao, Yejie Wang, Yingwei Ma, et al. Kimi-dev: Agentless training as skill prior for swe-agents. arXiv preprint arXiv:2509.23045, 2025c. Shunyu Yao, Jeffrey Zhao, Dian Yu, Nan Du, Izhak Shafran, Karthik Narasimhan, and Yuan Cao. React: Synergizing reasoning and acting in language models. arXiv preprint arXiv:2210.03629, 2022. Rui Ye, Zhongwang Zhang, Kuan Li, Huifeng Yin, Zhengwei Tao, Yida Zhao, Liangcai Su, Liwen Zhang, Zile Qiao, Xinyu Wang, Pengjun Xie, Fei Huang, Siheng Chen, Jingren Zhou, and Yong Jiang. Agentfold: Long-horizon web agents with proactive context management, 2025. URL https://arxiv.org/abs/2510.24699. Z.ai. GLM-4.7: Advancing the coding capability, 2025. URL https://z.ai/blog/glm-4.7. Guibin Zhang, Hejia Geng, Xiaohang Yu, Zhenfei Yin, Zaibin Zhang, Zelin Tan, Heng Zhou, Zhongzhi Li, Xiangyuan Xue, Yijiang Li, Yifan Zhou, Yang Chen, Chen Zhang, Yutao Fan, Zihu Wang, Songtao Huang, Francisco Piedrahita-Velez, Yue Liao, Hongru Wang, Mengyue Yang, Heng Ji, Jun Wang, Shuicheng Yan, Philip Torr, and Lei Bai. The landscape of agentic reinforcement learning for llms: A survey, 2025. URLhttps: //arxiv.org/abs/2509.02547. Yuxiang Zheng, Dayuan Fu, Xiangkun Hu, Xiaojie Cai, Lyumanshan Ye, Pengrui Lu, and Pengfei Liu. Deepresearcher: Scaling deep research via reinforcement learning in real- world environments, 2025. URL https://arxiv.org/abs/2504.03160. 15 Preprint Table 3: Full learning-curve results for joint RL on atomic skills. We report Avg@3 at multiple RL checkpoints on five atomic skills (IID) and five OOD composite benchmarks, together with Avg(IID) and Avg(OOD). Higher is better. Checkpoint Loc Edit Repr UTRevVerif Multi Term Refac SECAvg(OOD) Avg(IID) SFT0.665 0.458 0.542 0.359 0.5630.507 0.300 0.151 0.146 0.1360.2480.517 RL-iter-200.676 0.522 0.567 0.415 0.5660.525 0.348 0.154 0.142 0.1450.2630.549 RL-iter-300.674 0.500 0.562 0.367 0.5320.514 0.299 0.162 0.129 0.1320.2470.527 RL-iter-500.691 0.563 0.586 0.371 0.608 0.558 0.321 0.167 0.161 0.1510.2730.564 RL-iter-700.684 0.572 0.597 0.444 0.5890.565 0.380 0.195 0.168 0.1400.2770.577 RL-iter-800.705 0.575 0.606 0.437 0.654 0.555 0.394 0.192 0.153 0.1510.2890.595 RL-iter-900.701 0.578 0.601 0.454 0.6310.562 0.381 0.207 0.164 0.1640.2960.593 RL-iter-100 0.712 0.611 0.605 0.472 0.6220.585 0.389 0.182 0.171 0.1690.2990.604 A Full Learning-Curve Table for Joint RL on Atomic Skills In the main paper, we primarily present learning curves to visualize training dynamics of joint RL over atomic skills. In this appendix, we provide a tabular view of the same results for completeness and easier cross-task comparison. Specifically, Table 3 reports Avg@3 scores at multiple RL checkpoints (SFT initialization and several RL iterations) on all ten evaluation tasks, including the five atomic skills (Location, Editing, Reproduce, Unit Test, Review) and the five OOD composite benchmarks (Verified, Multilingual, Terminal, Refactoring, SEC-Bench). We additionally report two aggregate metrics: Avg (iid) as the mean Avg@3 across atomic skills, and Avg (ood) as the mean Avg@3 across OOD benchmarks. This table complements the plots by making it straightforward to (i) verify monotonicity or identify non-monotonic fluctuations per task, (i) compare improvement rates across skills and benchmarks at the same training iteration, and (i) select checkpoints that optimize either in-distribution atomic skills, OOD generalization, or their balance. Overall, the tabulated results confirm the main observation from the curves: joint RL produces broad improvements over the SFT initialization across the atomic-skill suite, while also yielding consistent gains on diverse OOD composite tasks. Notably, the aggregate averages (Avg (iid) and Avg (ood)) increase substantially from SFT to later RL iterations, indicating that joint optimization improves both core atomic capabilities and compositional generalization. B Ablation Tables: Single-Skill RL vs. Single-Benchmark RL To complement the learning-curve plots in the main paper, we provide tabular results for two ablation settings: (i) Editing-only RL, where RL optimizes only the atomic skill Code Editing; and (i) Verified-only RL, where RL optimizes only the composite benchmark SWE-bench Verified (bug fixing). Due to compute constraints, these ablation runs are trained up to 80 RL iterations (instead of the longer schedule used for joint atomic-skills RL), and we report checkpoints at RL-iter-50/70/80. Tables 4 and 5 report Avg@3 on all ten evaluation tasks for each checkpoint. Across both ablations, we consistently observe that while single-objective RL improves its target metric (editing for Editing-only RL; verified for Verified-only RL), it tends to yield weaker or less consistent gains on non-optimized skills and OOD benchmarks (e.g., refactoring, reproduction, and review). In contrast, joint RL over atomic skills (Table 3) provides more balanced improvements across capabilities, supporting our main claim that jointly scaling reusable atomic skills leads to stronger overall generalization. 16 Preprint Table 4: Full learning-curve results for Editing-only RL. Due to compute constraints, we train up to 80 RL iterations and report checkpoints at RL-iter-50/70/80. We report Avg@3 on five atomic skills and five OOD composite benchmarks. Higher is better. CheckpointLocEditReprUTRevVerifMultiTermRefacSEC SFT0.6650.4580.5420.3590.5630.5070.3000.1510.1460.136 RL-iter-500.6890.5520.5460.4230.593 0.5230.3740.1360.1570.147 RL-iter-700.6910.5660.5290.4290.5800.5450.3770.1560.1600.154 RL-iter-800.6780.5580.5350.4220.559 0.5320.3710.1510.1530.148 Table 5: Full learning-curve results for Verified-only RL (training only on SWE-bench Verified). Due to compute constraints, we train up to 80 RL iterations and report checkpoints at RL-iter-50/70/80. We report Avg@3 on five atomic skills and five OOD composite benchmarks. Higher is better. CheckpointLocEditReprUTRevVerifMultiTermRefacSEC SFT0.6650.4580.5420.3590.5630.5070.3000.1510.1460.136 RL-iter-500.6640.5110.5670.3490.5370.5130.3380.1720.1340.164 RL-iter-700.6680.5380.5700.3990.5300.5310.3670.1640.1490.141 RL-iter-800.6870.5640.5300.4080.5690.5550.3710.1720.1370.161 C Further Discussion C.1 Strict Data Decontamination. To ensure that our performance gains stem from genuine capability generalization rather than memorization, we implemented a rigorous decontamination pipeline. Prior to training, we collected the repository URLs and Commit IDs from all test sets of our 5 composite benchmarks. We then scanned our entire fine-tuning and RL corpus, removing any GitHub repositories, issues, or Pull Requests associated with these test instances. This ensures that the agent has never seen the codebases or specific problems used for evaluation during the RL training phase. C.2 Why not conduct joint composite RL? Compared with joint atomic skills RL, we argue that training directly on a broad set of composite tasks is fundamentally unscalable and inefficient, which is exactly the problem our Atomic Skills paradigm solves. It is computationally prohibitive to construct environ- ments and reward functions for every possible downstream application. Therefore, our approach offers a general-purpose scaling path, whereas Joint Composite RL would only be a ”multi-task specialist” limited to the specific tasks included in training. C.3 Model Scale and Ability Generalization Intuitively, improvements in model generalization achieved through this joint RL training approach may stem from the efficacy of the algorithm itself or from the inherent generaliza- tion capabilities of large-parameter models (e.g., 106B). We discuss this distinction in greater detail below. 17 Preprint •Controlled Comparison (Relative Gain): All our experiments compare the same base model (GLM-4.5-Air-Base). As shown in Table 2, our method achieves a 30% relative improvement (from 30.0% to 38.9% on SWE-bench Verified) over the SFT baseline using the exact same model size. This isolates the contribution of the algorithm from the model scale. • Necessity of Scale for Agentic RL: Complex Agentic RL (involving tool usage, long contexts, and environment feedback) exhibits a ”threshold effect.” Smaller models often struggle with the basic instruction following required to even begin RL exploration. Using a 100B+ model ensures the stability required to verify the effectiveness of the training paradigm itself. D Related Work on SWE-agent The emergence of SWE-bench Jimenez et al. (2024) has catalyzed significant attention within the community toward coding agents. Currently, mainstream coding agents leverage diverse scaffolding frameworks Wang et al. (2025b); Yang et al. (2024); OpenAI (2025a); Anthropic (2025b); Ma et al. (2025b) to resolve authentic GitHub issues, a process that inherently involves multi-turn tool execution. In terms of training, specifically adopting the reinforcement learning with verifiable rewards paradigm DeepSeek-AI et al. (2026); Team et al. (2025c), the community has diverged into two primary research streams: one utilizes test patches to verify the correctness of agent trajectories Ma et al. (2024); Du et al. (2025); Ma et al. (2025a), while the other employs independent reward models or rule-based heuristics to provision dense reward signals Wei et al. (2025); Shum et al. (2025); Xu et al. (2025). Beyond the predominant task of automated bug-fixing task, recent studies have also expanded into more pragmatic engineering scenarios, such as file localization Chen et al. (2025); Reddy et al. (2025), code review McAleese et al. (2024); GitHub (2025), unit tests generation Lee et al. (2025a); Ma et al. (2025d), and code efficiency optimization Ren et al. (2025); Huang et al. (2025). E Prompts for Atomic Skills This appendix provides the prompts used to instantiate our five atomic skills. Each skill is defined as a standalone agentic task with a fixed interface and a structured output requirement. All skills share a common system prompt and are executed in the same sandboxed environment. For reproducibility, we report the exact prompt templates below, where placeholders in braces (e.g.,workspace,issuedescription) are populated with task-specific content at runtime. E.1 Shared System Prompt You are a helpful assistant that can interact with a computer to solve tasks. <IMPORTANT> * If user provides a path, you should NOT assume it's relative to the current working directory. Instead, you should explore the file system to find the file before working on it. </IMPORTANT> E.2 Atomic Skill Prompts Code Localization. Location: <uploaded_files> workspace </uploaded_files> I've uploaded a language code repository in the directory workspace. 18 Preprint Consider the following request: <pr_description> requirement </pr_description> Your task is to locate ALL files that need to be modified to meet the requirements of this pr. Please follow these steps: 1. Analyze the issue: Carefully read the pr to understand what needs to be changed. 2. Explore the codebase: Use tools to explore the repository structure and locate relevant files. DO NOT edit any files - only inspect them. 3. Identify all relevant files: Only consider all python files that might need modification. DO NOT consider other types of files (like configuration files, documentation files, test files, etc.) 4. Submit your result: After your analysis, provide your final answer with the list of files that need to be modified. Important guidelines: - Be thorough - include ALL files that need modification, not just the main implementation files - Only include files that actually need to be MODIFIED, not files you just inspected - Use relative paths from the repository root (e.g., src/main.py, not /testbed/src/main.py) - DO NOT include the /testbed/ prefix in your paths - One file path per line - Do NOT actually edit or fix the code - only locate the files Output format: When you have identified all files, write them to a file at /testbed/location.txt. Put one file path per line in this file. Use the str_replace_editor tool with the create command to create this file. Code Editing. Editing: <uploaded_files> workspace </uploaded_files> I've uploaded a python code repository in the directory workspace. Consider the following issue description: <issue_description> issue_description </issue_description> The changes required to address this issue should be made specifically at the following code location: <code_location> location </code_location> Can you help me implement the necessary changes to the repository at the specified code location so that the requirements specified in the <issue_description> are met? I've already taken care of all changes to any of the test files described 19 Preprint in the <issue_description>. This means you DON'T have to modify the testing logic or any of the tests in any way! Your task is to make the minimal changes to the code at the specified location in the <uploaded_files> directory to ensure the <issue_description> is satisfied. Follow these steps to resolve the issue: 1. First, carefully examine the code at the specified <code_location> and understand how it relates to the <issue_description> 2. Edit ONLY the source code at the specified location to resolve the issue - do not modify other parts of the codebase 3. Ensure that your changes are minimal and directly address the requirements in the <issue_description> Your thinking should be thorough and so it's fine if it's very long. Focus your changes exclusively on the code location provided. Issue Reproduction. <uploaded_files> workspace </uploaded_files> I've uploaded a language code repository in the directory workspace. Consider the following issue description: <issue_description> issue_description </issue_description> Your task is to create a reproduction script that demonstrates the issue described in the <issue_description>. You DO NOT need to fix the issue - only reproduce it to confirm the problem exists. The development python environment is already set up for you (i.e., all dependencies already installed), so you don't need to install other packages. Follow these phases to reproduce the issue: Phase 1. READING: read the problem and understand it in clear terms 1.1 If there are code or config snippets, express in words any best practices or conventions in them. 1.2 Highlight error messages, method names, variables, file names, stack traces, and technical details. 1.3 Explain the problem in clear terms. 1.4 Enumerate the expected behavior vs. actual behavior. 1.5 Identify the key symptoms that indicate the issue is present. Phase 2. RUNNING: understand how to run the repository 2.1 Follow the readme to understand the project structure. 2.2 Understand the test framework and how tests are typically run. 2.3 If tests are mentioned in the issue, try running them to observe the problem. Phase 3. EXPLORATION: find the files that are related to the problem 3.1 Use grep to search for relevant methods, classes, keywords and error messages. 20 Preprint 3.2 Identify all files related to the problem statement. 3.3 Read the relevant code to understand the current behavior. 3.4 Understand why the issue occurs based on the code structure. Phase 4. REPRODUCTION SCRIPT CREATION: create a standalone script to reproduce the issue 4.1 Look at existing test files in the repository to understand the test format/structure. 4.2 Create a file named reproduce.py in the root directory testbed. IMPORTANT: The file MUST be named exactly reproduce.py. 4.3 The script should: - Clearly demonstrate the problem described in the issue - Print informative messages showing what is being tested - Show the expected behavior vs. actual behavior - Exit with a clear message indicating whether the issue was successfully reproduced 4.4 Run the reproduction script to confirm it reproduces the issue. 4.5 Adjust the script as necessary until it reliably demonstrates the issue. 4.6 Make sure the script runs successfully and clearly shows the issue. 4.7 VERIFY: Confirm that the final reproduction script is saved as reproduce.py in testbed. Once you have successfully created reproduce.py in testbed and verified that it demonstrates the issue, your task is complete. Be thorough in your exploration and testing. It's fine if your thinking process is lengthy. Quality and completeness are more important than brevity. Unit-Test Generation. <uploaded_files> workspace </uploaded_files> You are given a Python repository in the directory. Inside this repository the implementation of the target function has already been completed for you. Your task is exclusively to finish the unit-test file(s) that exercise that function. Provided information - Location of the function(s) to test: function_list - Location of the unit-test file(s) to complete: test_list (these files currently contain only skeletons, imports, and empty test methods) - How to run the tests: exec_comand Constraints & requirements The original functions are implemented correctly, but your unit tests should be able to detect if these functions were to contain errors. You should design tests that would fail if the functions were implemented incorrectly. 1. Do NOT modify any source file outside the indicated test file(s). 2. Preserve existing function/class names and signatures exactly as they appear in the skeleton. 3. Write comprehensive, deterministic unit tests that cover: - normal inputs - edge cases - error conditions (if applicable) 4. All tests must pass when executed with the provided command(s). 21 Preprint 5. Aim for 100 % test coverage of the supplied function set, as measured by the repository's coverage tool (if any). Workflow 1. Inspect the already-implemented function to understand its contract, return values, and possible exceptions. 2. Fill in every empty test method in the indicated test file(s) with assertions that verify correct behaviour. 3. Run the test command frequently; ensure all tests pass before declaring completion. 4. Add extra helper methods or data providers inside the test file if needed, but keep them private (leading underscore). Deliver a complete test-suite that locks in the correctness of the provided code. Code Review. <uploaded_files> workspace </uploaded_files> I've uploaded a language code repository in the directory workspace. Review the following PR: <pr_description> pr_description </pr_description> <pr_code> pr_code </pr_code> Please review the pr_code to determine whether it correctly fixes the issue described in the pr_description. Review Requirements: - If the code is correct: Provide a comprehensive summary of your review explaining why the fix is appropriate. - If the code is incorrect: Identify and explain the problematic parts in detail. Final Judgment: After your review, you must provide a final judgment using the following format: <review> [Your review here] </review> <judgment> YES or NO </judgment> - Use "YES" if the pr_code successfully fixes the issue described in the pr_description. - Use "NO" if the pr_code doesn't fix the issue described in the pr_description. 22