WorksComputer Science
Let Execution Do the Teaching
Abstract
Improving a coding model is a sequence of decisions: find the limiting behavior, create useful practice, and determine which attempts deserve reinforcement. We investigate a practical way to make those decisions increasingly repeatable by grounding feedback in execution. Starting from GLM-4.7-Flash, the work combines whole-file supervised fine-tuning, targeted C++ repair curricula, group-relative reinforcement learning, and verifiers that turn program behavior into structured rewards. Compiler errors and failing tests provide specific contexts for repair practice, while executable checks score the resulting programs. We evaluate the trained models on 26 C++ coding tasks, measuring both initial success and completion after test feedback. The strongest reported post-training configuration achieves 45.2% success in the first test round and 61.5% within two rounds. These results come from an assisted development suite with evolving prompt contracts; the strongest configuration uses four selected evaluation trials and includes six tasks also used in training. The study describes an execution-guided workflow for improving coding models, including how repair tasks are constructed, how program behavior determines rewards, and how the resulting models are evaluated.
Introduction
A generated C++ implementation can fail during compilation or when tested against the task’s requirements. For example, a phone-number cleaner may accept a number whose exchange begins with 1, violating the task specification. Another implementation may fail to compile because a data member and a method share the same name. The first failure requires a change to input validation; the second requires a correction to the C++ interface.
We examine whether execution-graded practice improves a coding model’s initial task completion and its ability to repair a failed attempt using test feedback. Compiler diagnostics and test failures identify the errors addressed by the repair tasks. Executable checks then score candidate programs against the task requirements.
We study GLM-4.7-Flash [1] in a whole-file editing workflow. The model receives a task and source files, then returns complete replacement file contents. A successful response must follow the editing interface, compile, and pass the behavioral checks. Evaluation distinguishes response-format errors, compilation failures, and incorrect program behavior.
Supervised fine-tuning [2] trains the model on full solutions and prepared repair examples. Reinforcement learning samples candidate solutions and uses their execution-derived rewards to guide updates. We use low-rank adapters [3] for these updates. The verifiers score individual behavioral requirements, and recorded execution outcomes make those scores inspectable. Evaluations of saved checkpoints measure initial task completion and completion after test feedback.

Figure 1. Execution-guided post-training overview. Blue groups task construction and validation, green shows model training, and ochre shows checkpoint evaluation. Within the training loop, execution-derived rewards guide GRPO adapter updates. The dashed handoff marks the researcher’s selection of the next intervention. This schematic summarizes components across experiments with different training lineages and reward configurations; the evaluation qualifications in § 5.2 apply.
Related Work
Execution-derived supervision. LETI fine-tunes code generators with a language-modeling objective on sequences conditioned on execution feedback, including diagnostic text and reward tokens indicating whether a solution is correct. [4] Our reinforcement-learning experiments use diagnostic context in prepared repair prompts and scalar rewards computed from executable checks. The diagnostic context specifies the failure to repair; the reward measures the behavior of the resulting program.
Executable task construction. SWE-smith creates repository-level training tasks by introducing changes that cause previously passing tests to fail, then generates issue descriptions from the code changes and test evidence. [5] Our curricula use C++ exercises with specified interfaces and editable files, including full-solution tasks and prepared repairs targeting named failure mechanisms. The bank-account curriculum checks reference and faulty implementations before packaging its exercises. The comparison concerns how executable repair tasks are constructed and validated; this study does not evaluate repository-scale task generation.
Policy-dependent curricula. FrogNano’s TaskPilot uses current-policy rollouts to admit, revise, and re-evaluate generated repository tasks. [6] Our generalized curriculum also uses observed policy success for task selection: an admitted task must have one to three first-round successes across four recorded trials from a specified checkpoint. This rule selects among prepared tasks. TaskPilot additionally uses rollout feedback to revise the tasks themselves during iterative synthesis.
Editing interfaces. SWE-agent examines how tools for repository navigation, editing, and execution affect performance while holding the underlying model fixed. [7] Our study trains a model to return complete replacement contents for allowed source files, which are then parsed, compiled, and tested. The reported checkpoint comparisons include changes to the evaluation prompts and supplied API/build information. They therefore do not isolate the effect of model updates from changes in the evaluation setup.
Methodology
Failure mechanisms and repair contexts
We construct targeted repair tasks for specific failure mechanisms. For example, a C++ phone-number validation implementation failed to compile because its private data member number collided with its public number() method. The repair prompt includes the faulty header and a diagnosis of the name collision. The model must produce an implementation that compiles against the required public interface.
Another repair task targets missing checks on North American area and exchange prefixes. A candidate can compile while accepting numbers with invalid area or exchange prefixes. The repair prompt pairs defective source with the requirement that prefixes beginning with 0 or 1 raise an error. The two repairs address different failures: the C++ declaration collision and the missing area- and exchange-prefix checks.
| Concrete input or observation | Required behavior | Lesson |
| +1 (223) 456-7890 | Return 2234567890; render (223) 456-7890. | Preserve valid normalization. |
| 2231567890 | Throw std::domain_error. | Validate the exchange prefix. |
Member named number and method number() | Produce an interface that compiles. | Repair the declaration collision. |
Table 1. Phone Number inputs, requirements, and targeted repair mechanisms.
Curriculum construction
The task builder emits eight prompts for this example: one full-solution task and seven repair contexts. The repairs cover missing definitions, invalid prefixes, character handling, length, country code, display formatting, and the observed name collision. All eight prompts specify the same public interface and editable files. The model generates complete replacement contents for those files, and the runner checks the resulting program.
Use execution to check both the exercise and the answer
The task builder validates exercises with reference implementations and faulty controls. In the bank-account example, it introduces a compilation or linking fault and a state-management fault that retains the old balance after reopening. A separate boundary fault accepts a zero amount. Before packaging the exercises, the builder requires the reference implementation to pass and each faulty candidate to fail at its expected stage.
For the phone-number validation exercise, the verifier compiles the candidate against the required C++17 interface and runs twelve Boolean checks. These checks cover normalization, invalid characters, length and country-code partitions, prefix restrictions, and public output behavior. A kernel is one scored Boolean check and may contain several test inputs. The implementation organizes the twelve checks into four groups of three; Table 2 summarizes their coverage.
| Group | Checks |
| Basic valid-input behavior (PH-E01) | Plain ten-digit input, area-code and number accessors, and a leading country code of 1. |
| Formatting and rejection rules (PH-E02) | Permitted formatting; invalid length, country code, and characters; invalid area and exchange prefixes. |
| Formatting and boundary cases (PH-E03) | Whitespace, the valid number 9999999999, exact string formatting, and empty, overlong, or malformed inputs. |
| Combined interface and input checks (PH-E04) | Consistent public outputs, multiple valid formats, and combined rejection cases. |
Table 2. Coverage of the four verification groups. Descriptive labels summarize the checks; identifiers match the released implementation. Each group contains three Boolean kernels.
From twelve outcomes to one reward. For checks , each equal to 0 or 1:
All twelve passing gives +1. Ten passing gives +2/3. All twelve failing gives -1. These are arithmetic examples of the reward rule, not sampled experimental outcomes.
Programs receive different rewards according to how many checks they pass. Recorded check outcomes show which requirements a program passes or fails.
The verifier writes the twelve outcomes as a 12-bit record in the test log. The reward parser accepts that record only if the harness’s completion marker directly follows it. The marker contains a fresh random token for the run. If the harness reports a passing result without the expected record, the reward path flags the sample as an infrastructure error rather than accepting it as a pass.
Task admission
If every attempt receives the same reward, that group offers no reward preference among its samples. The multi-task C++ curriculum admits a task only if it has one to three first-round successes across four recorded trials from the specified source checkpoint. The admission procedure verifies the receipt file hashes and their checkpoint, run, and task-suite identifiers. It recomputes trial and success counts and compares them with the admission record.
GRPO training and checkpoint evaluation
GRPO [8] samples several responses to the same prompt and uses their relative rewards to guide the update. In the phone-number validation run, eight prompts each produced 32 samples, yielding 256 responses per rollout batch. We trained a LoRA adapter and saved it for checkpoint evaluation. [3]
After training, checkpoint evaluation measured first-round solving and repair after test feedback.
Engineering
Response parsing and file validation
The parser extracts filename-labeled code blocks from the final answer after any reasoning text. It checks each target against the allowed file set. The parser accepts Markdown-wrapped labels and path labels with an allowed basename but records them as formatting errors. In strict mode, duplicate file blocks and targets outside the allowed set cause rejection. With boundary recovery enabled, the parser skips forbidden targets and keeps the last duplicate block while marking the response as format-invalid. The runner compiles the candidate from the parsed file edits.
Infrastructure error handling
The reward path distinguishes candidate failures from execution-environment errors. It retains the raw execution reward and diagnostic flags separately from the adjusted training score. When using this adjustment, the reward path groups samples by rollout and problem. Each infrastructure-invalid sample receives the mean training score of the valid samples in its group. If the group contains no valid samples, every sample receives a zero training score. Assigning the valid-group mean removes the invalid sample’s deviation from the mean after group centering. The original reward and error flags remain in the record.
Adapter loading and synchronization
After loading previously trained adapter weights, the integration refreshes the optimizer’s FP32 master weights to match the loaded adapter. When training offload and LoRA are enabled, it restores saved CPU adapter snapshots to their original devices before the weight updater synchronizes the rollout service.
Shared C++ verification
The shared verifier checks source structure and API requirements, separate compilation and linking, official-test completion, response integrity, and candidate-output completeness. The code calls the five-group profile live. The full profile adds warning and sanitizer diagnostics and requires all selected checks to pass for a profile-level pass. Response checks examine repeated text and incomplete code blocks. Candidate test runs must complete without crashes or timeouts and satisfy the required tests.
Before awarding a positive verification reward, the implementation validates the check records and the reference and candidate execution results. It requires successful reference execution, verified candidate completion, zero required return codes, and no execution-failure flags. The runner also checks that candidate source files remain unchanged across verification. A validated pass earns , or when a recoverable formatting error remains. Incomplete candidates receive scores between and . Their partial credit comes from weighted passed-check results and the available semantic test fraction. The implementation flags invalid verification records as infrastructure errors.
For the dice-scoring exercise, Yacht, the checker enumerates all 7,776 ordered rolls of five six-sided dice across twelve scoring categories. For the list-comparison exercise, Sublist, it tests equality and contiguous sublist or superlist relationships. Its exhaustive check covers 115,600 ordered pairs of nonempty lists of lengths one through four over the values . The checker handles empty-list cases separately. For the perfect-number classification exercise, the reference implementation sums proper divisors using a 64-bit accumulator and divisor pairs. A separate checker computes the sum through prime factorization. Its tests include inputs from 1 through 4,096 and large values near the 32-bit integer limit.
For tasks with required task-specific checks, the combined reward stays positive only when both shared and task-specific verification pass. Failure in either produces a non-positive score. The implementation flags invalid task-specific results as infrastructure errors.
This section describes the released verifier implementation. The checkpoint experiments in § 5 use the reward and evaluation configurations recorded for their own runs. The source tracks later verifier changes separately; those changes are not retroactively part of these results.
Experiments
Evaluation protocol
Fixed26 is the project’s fixed set of 26 C++ coding tasks evaluated through Aider [9]. Four trials per reported configuration produce 104 task-trial trajectories. The first-round metric asks whether a task passes its first test round. The cumulative two-round metric asks whether it is solved by the end of the second test round, after feedback. A test round may contain multiple model requests.
Conditional recovery is the fraction of first-round failures that become successes in round two. Keeping this denominator visible helps distinguish a model that starts more reliably from one that repairs more effectively.
| Metric | Calculation across four trials | Interpretation |
| First-round mean | First-round successes / 4 | Tasks solved immediately, out of 26. |
| Two-round mean | Tasks solved by round two / 4 | Cumulative completion, out of 26. |
| Conditional recovery | New round-two successes / first-round failures | Use of the available feedback opportunity. |
Table 3. Evaluation metrics and their denominators.
Evaluated configurations and prompt contracts
The results include base GLM-4.7-Flash, two supervised configurations, two execution-midband RL configurations, Phone Number GRPO, and Generalized C++ GRPO. SFT v5 uses 1,117 Aider-format examples over three epochs. Synth v1 uses 260 examples, with epoch 50 selected. Recorded warm starts carry Synth v1 into midband RL v2, then through D&D Character into Phone Number. The release also reports the multi-task Generalized C++ checkpoint. Luna supplies a separately hosted reference evaluation.
Prompt contracts are part of each result. Base and Luna use original prompts; SFT v5 uses fixed26-contract; Synth, Phone Number, and Generalized C++ use fixed26-contract-v2. The contract overlays supply API/build information derived from the tests. These are development-suite evaluations used in the project’s improvement process. The Generalized C++ result uses a selected best-four cohort and has six training task IDs in common with Fixed26.
Training configuration
The Phone Number receipt records 20 GRPO updates on eight H100 80 GB GPUs, BF16 execution, tensor parallelism four [10], and expert parallelism eight. LoRA uses rank 16 and alpha 32. The rollout batch contains eight prompts with 32 responses each; learning rate is , with KL coefficient 0.1. The scored adapter is iteration 14. Appendix A gathers the full settings and the result-specific evidence checks.

Figure 2. Mean tasks solved out of 26, from the release results. Four trials per row. *Generalized C++ is the selected best-four cohort. Bars show observed outcomes under the contracts in § 5.2; the complete set of configurations appears below.
Table 4: Release-reported means and recovery counts. Each row contains four trials and 104 task-trial trajectories. The Generalized C++ row is a development-suite evaluation using test-derived API/build prompt information with the selection and training overlap described in § 5.2.
| Configuration | First round mean / 26 | Two rounds mean / 26 | Conditional recovery |
| GLM-4.7-Flash base | 0.50 (1.9%) | 4.50 (17.3%) | 16/102 (15.7%) |
| Luna reference | 6.25 (24.0%) | 16.75 (64.4%) | 42/79 (53.2%) |
| SFT v5 | 6.00 (23.1%) | 10.25 (39.4%) | 17/80 (21.2%) |
| Synth v1, epoch 50 | 9.50 (36.5%) | 12.00 (46.2%) | 10/66 (15.2%) |
| Execution-midband RL v1 | 8.25 (31.7%) | 13.00 (50.0%) | 19/71 (26.8%) |
| Execution-midband RL v2 | 10.50 (40.4%) | 14.50 (55.8%) | 16/62 (25.8%) |
| Phone Number, iter 14 | 11.25 (43.3%) | 15.25 (58.7%) | 16/59 (27.1%) |
| Generalized C++, iter 14* | 11.75 (45.2%) | 16.00 (61.5%) | 17/57 (29.8%) |
Table 4. Release-reported means and recovery counts.
Reported completion results
The first-round mean rises from 0.5 for the base configuration to 6 for SFT v5 and 9.5 for Synth v1. The selected Generalized C++ cohort reaches 11.75 first-round and 16 cumulative solves. These results compare experimental configurations with different prompt contracts.
Solving and repairing move differently
Synth v1 solves more tasks in the first round than SFT v5, yet its conditional recovery is 15.2%, compared with 21.2% for SFT v5. The Phone Number checkpoint reaches 27.1%, and the selected Generalized C++ cohort reaches 29.8%. Luna’s 53.2% recovery rate provides a useful reference point under its separate hosted setup.
A prepared repair prompt supplies a known problem state and diagnostic context during training. A two-round evaluation asks the agent to react to feedback from its own preceding attempt. We use two-round completion to examine the relationship between practice on prepared repairs and repair after test feedback.
Task-level outcomes
Across four trials, first-round success on phone-number validation changes from 1/4 at Synth v1 to 4/4 at the Phone Number checkpoint. Other tasks move too: Parallel Letter Frequency rises from 0/4 to 3/4, while Gigasecond and Sublist decline. These are checkpoint-level observations across the intervening training lineage.
| Task | Synth v1 first-round successes | Phone Number first-round successes |
| Phone Number | 1 / 4 | 4 / 4 |
| Parallel Letter Frequency | 0 / 4 | 3 / 4 |
| Gigasecond | 3 / 4 | 0 / 4 |
| Sublist | 3 / 4 | 1 / 4 |
Table 5. Selected task-level outcomes from the released per-task table.
Uncertainty estimates
The released task-bootstrap [11] intervals show the variation across this small task suite. Phone Number’s first-round mean is 11.25/26 with a 95% interval of 7.5-15; its cumulative mean is 15.25/26 with an interval of 11-19.25. Generalized C++ has corresponding intervals of 8-15.5 and 11.75-20. These summarize the reported cohorts; selection and prompt-contract differences remain part of the experimental setup.
Discussion
Research decisions and automated operations
People specify the task, choose the behavior to practice, design checks, and decide which experiment to run. The configured system repeatedly builds candidates, tests their behavior, assigns rewards, updates adapters, and records evaluations.
| Research and engineering decisions | Repeated operations handled by the system |
| Choose the target behavior and intervention. | Construct the configured task variants and prompts. |
| Define requirements, references, and controls. | Compile, execute, score, and retain check outcomes. |
| Select training settings and checkpoints to study. | Sample responses, update adapters, and run configured evaluations. |
| Interpret results and choose the next experiment. | Produce task-level records for comparison and diagnosis. |
Table 6. Research decisions and repeated operations handled by the configured system.
Future work
Future work could use recorded failures to support diagnosis and selection of the next training intervention. It could also expand independently implemented task-specific checkers and build curricula that preserve acquired behavior while introducing new mechanisms. Further studies could examine repair using feedback from the model’s own attempts and compare interventions on fresh task families under matched evaluation contracts.
Conclusion
Compiler diagnostics and test outcomes provide feedback for post-training. This project connects that feedback to targeted C++ practice, structured rewards, low-rank model adaptation, and checkpoint-level evaluation. The reported post-training configurations have higher task completion than the base configuration, under differing prompt contracts. The Generalized C++ result uses a selected trial cohort and has training-task overlap with the evaluation suite. Task-level results show improvements and regressions.
Use of AI Tools
OpenAI Codex was used to assist with manuscript organization, drafting and revision, literature searches, and LaTeX preparation. The authors reviewed and edited the resulting material and take full responsibility for the final manuscript.
Training configuration and reward definitions
Training configuration
| Setting | Recorded value |
| Base model and adaptation | GLM-4.7-Flash; LoRA rank 16, alpha 32. |
| Training hardware | 8 × H100 80 GB; BF16; tensor parallel 4; expert parallel 8. |
| Dispatch and serving | DeepEP [12] flex dispatch; SGLang [13] rollout service; Miles [14] training integration. |
| Rollout and batch | 8 prompts × 32 samples; global batch 256; 20 GRPO updates. |
| Optimization | Learning rate ; constant schedule; warmup fraction 0.1; KL coefficient 0.1. |
| Generation | Sequence limit 12,288; response limit 8,192; temperature 0.7; thinking enabled. |
| Warm start and scored checkpoint | Initial adapter: D&D Character, iteration 19. Evaluated adapter: Phone Number, iteration 14. |
Table 7. Recorded phone-number validation training configuration.
These settings come from the released phone-number validation training record and launch configurations. The record also reports wall time and peak memory; timing is marked unverified.
Experiment-specific reward definitions
| Reward path | Definition and role |
| Whole-file execution reward | Default scoring: prohibited edits or runtime violations -1; other parse failures -0.8; compilation failure or candidate timeout -0.5; full pass +1; otherwise 0.6 × the fraction of passed tests. Recoverable formatting errors incur a penalty of 0.1; scores are clipped to [-1,1]. A strict binary mode is also available. |
| Phone-number validation reward | Mean of 12 signed Boolean check outcomes, in [-1,1]. The recorded outcomes replace the default execution reward. Execution-environment errors are flagged separately. |
| Current shared C++ verification reward | Validated pass +1 (0.975 with a recoverable formatting error). Failed candidates receive -1 plus weighted passed-check credit and available semantic-test credit, clipped to [-1,0]. Invalid execution records are flagged as infrastructure errors. |
| Current task-specific verification adjustment | A positive shared verification score is retained when required task-specific checks pass. Otherwise use 0.5 min(, 0) + 0.5(). Invalid task-specific evaluations are flagged separately. |
Table 8. Experiment-specific reward definitions and roles.
In the adjustment formula, denotes the shared verification score and the task-specific requirement fraction. The current shared C++ verification reward weights its six scored checks by 0.10, 0.20, 0.20, 0.45, 0.025, and 0.025. These definitions apply to their respective implementations. Historical checkpoints retain the reward configurations recorded for their runs.
Results, artifacts, and reproduction
Trial variability and confidence intervals
Scores are numbers of tasks solved out of 26; recovery intervals are percentages. Standard deviations (SD) and ranges are across trials. Confidence intervals use 100,000 task-clustered bootstrap resamples, keeping all four trial outcomes together for each sampled task. The Generalized C++ row uses a selected best-four cohort.
| Configuration | First round SD; range; 95% CI | Two rounds SD; range; 95% CI | Recovery 95% CI |
| Base | 0.58; 0-1; 0-1.25 | 1.29; 3-6; 2.25-6.75 | 7.8-24.8% |
| Luna | 1.89; 5-9; 3.25-9.5 | 1.50; 15-18; 12.75-20.5 | 36.8-70% |
| SFT v5 | 1.63; 4-8; 3-9.25 | 1.71; 8-12; 7-13.75 | 11.9-31.6% |
| Synth v1 | 0.58; 9-10; 5.75-13.5 | 0.82; 11-13; 8.25-15.75 | 7.4-24.4% |
| Midband RL v1 | 2.06; 6-11; 4.75-12 | 0.82; 12-14; 9-17 | 14.5-41.4% |
| Midband RL v2 | 1.29; 9-12; 7-14 | 2.08; 12-17; 10.5-18.5 | 12.9-41.9% |
| Phone Number | 0.50; 11-12; 7.5-15 | 0.50; 15-16; 11-19.25 | 13.1-44.2% |
| Generalized C++* | 1.50; 10-13; 8-15.5 | 1.41; 14-17; 11.75-20 | 14.5-48.9% |
Table 9. Trial variability and task-bootstrap confidence intervals for the reported configurations.
Reproduction checks
The run manifests identify the datasets, adapters, evaluation archives, and launch configurations used in each reported experiment.
These commands check the recorded SFT v5 and Phone Number results and artifact identities. Both checks were reported as successful during study preparation. Run them from the release checkout:
python results/sft-v5-aiderfmt-1117-4trials/audit/verify.py
python results/phone-number-kernel12-GRPO20/recompute.py --check
Use each result’s recorded launch configuration to reproduce its evaluation. The Generalized C++ run also requires its task registry, admission inputs, and associated run archive.
Data and model artifacts
Phone-number validation adapter and run archive
Multi-task C++ adapter and selected evaluations
Supervised training dataset (Synth v1)
Checkpoint evaluation archive (Synth v1)
References
- [1]Z.ai. 2026. GLM-4.7-Flash. Model card, Hugging Face. https://huggingface.co/zai-org/GLM-4.7-Flash.
- [2]Jason Wei, Maarten Bosma, Vincent Y. Zhao, Kelvin Guu, Adams Wei Yu, Brian Lester, Nan Du, Andrew M. Dai, and Quoc V. Le. 2022. Finetuned Language Models Are Zero-Shot Learners. In International Conference on Learning Representations.arxiv.org/abs/2109.01652
- [3]Edward J. Hu, Yelong Shen, Phillip Wallis, Zeyuan Allen-Zhu, Yuanzhi Li, Shean Wang, Lu Wang, and Weizhu Chen. 2022. LoRA: Low-Rank Adaptation of Large Language Models. In International Conference on Learning Representations.arxiv.org/abs/2106.09685
- [4]Xingyao Wang, Hao Peng, Reyhaneh Jabbarvand, and Heng Ji. 2024. LETI: Learning to Generate from Textual Interactions. In Findings of the Association for Computational Linguistics: NAACL 2024, pages 223–239. Association for Computational Linguistics. doi:10.18653/v1/2024.findings-naacl.16.DOI
- [5]John Yang, Kilian Lieret, Carlos E. Jimenez, Alexander Wettig, Kabir Khandpur, Yanzhe Zhang, Binyuan Hui, Ofir Press, Ludwig Schmidt, and Diyi Yang. 2025. SWE-smith: Scaling Data for Software Engineering Agents. arXiv preprint, arXiv:2504.21798.arxiv.org/abs/2504.21798
- [6]Minseon Kim, Zhengyan Shi, Emiliano Penaloza, Christopher Cui, Roger Creus Castanyer, Maryam Hashemzadeh, Isadora White, Jonathan Light, Jeonghye Kim, Matheus Pereira, Darya Moldavskaya, Chimnay Singh, Fabio Vera, Baolin Peng, Xingdi Yuan, Marc-Alexandre Côté, and Alessandro Sordoni. 2026. FrogNano: Training a 4B Coding Agent via Online Task Synthesis. arXiv preprint, arXiv:2609.07925, version 4.arxiv.org/abs/2609.07925
- [7]John Yang, Carlos E. Jimenez, Alexander Wettig, Kilian Lieret, Shunyu Yao, Karthik Narasimhan, and Ofir Press. 2024. SWE-agent: Agent-Computer Interfaces Enable Automated Software Engineering. In Advances in Neural Information Processing Systems, volume 37, pages 50528–50652. Curran Associates, Inc. doi:10.52202/079017-1601.
- [8]Zhihong Shao, Peiyi Wang, Qihao Zhu, Runxin Xu, Junxiao Song, Xiao Bi, Haowei Zhang, Mingchuan Zhang, Y. K. Li, Y. Wu, and Daya Guo. 2024. DeepSeekMath: Pushing the Limits of Mathematical Reasoning in Open Language Models. arXiv preprint, arXiv:2402.03300.arxiv.org/abs/2402.03300
- [9]Aider. 2024. o1 tops aider’s new polyglot leaderboard. Benchmark description, Aider. 21 December 2024. https://aider.chat/2024/12/21/polyglot.html.
- [10]Mohammad Shoeybi, Mostofa Patwary, Raul Puri, Patrick LeGresley, Jared Casper, and Bryan Catanzaro. 2019. Megatron-LM: Training Multi-Billion Parameter Language Models Using Model Parallelism. arXiv preprint, arXiv:1909.08053.arxiv.org/abs/1909.08053
- [11]B. Efron. 1979. Bootstrap Methods: Another Look at the Jackknife. The Annals of Statistics, 7(1):1–26. doi:10.1214/aos/1176344552.DOI
- [12]Chenggang Zhao, Shangyan Zhou, Liyue Zhang, Chengqi Deng, Zhean Xu, Yuxuan Liu, Kuai Yu, Jiashi Li, and Liang Zhao. 2025. DeepEP: An Efficient Expert-Parallel Communication Library. Computer software. https://github.com/deepseek-ai/DeepEP.
- [13]Lianmin Zheng, Liangsheng Yin, Zhiqiang Xie, Chuyue Sun, Jeff Huang, Cody Hao Yu, Shiyi Cao, Christos Kozyrakis, Ion Stoica, Joseph E. Gonzalez, Clark Barrett, and Ying Sheng. 2024. SGLang: Efficient Execution of Structured Language Model Programs. In Advances in Neural Information Processing Systems, volume 37, pages 62557–62583. Curran Associates, Inc. doi:10.52202/079017-2000.DOI
- [14]Miles Team. 2026. Miles: Enterprise-Grade Reinforcement Learning for Large-Scale Model Post-Training. Computer software. https://github.com/radixark/miles.