betaFeedback

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.

Execution-guided post-training overview showing task construction and verifier design, model training, and checkpoint evaluation

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 observationRequired behaviorLesson
+1 (223) 456-7890Return 2234567890; render (223) 456-7890.Preserve valid normalization.
2231567890Throw 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.

GroupChecks
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 b1,…,b12b_1,\ldots,b_{12}, each equal to 0 or 1:

R=112∑k=112(2bk−1).(1)R = \frac{1}{12}\sum_{k=1}^{12}(2b_k-1). \tag*{(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 +1+1, or +0.975+0.975 when a recoverable formatting error remains. Incomplete candidates receive scores between −1-1 and 00. 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 {−1,0,1,2}\{-1, 0, 1, 2\}. 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.

MetricCalculation across four trialsInterpretation
First-round meanFirst-round successes / 4Tasks solved immediately, out of 26.
Two-round meanTasks solved by round two / 4Cumulative completion, out of 26.
Conditional recoveryNew round-two successes / first-round failuresUse 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 3×10−53 \times10^{-5}, with KL coefficient 0.1. The scored adapter is iteration 14. Appendix A gathers the full settings and the result-specific evidence checks.

Bar chart of mean tasks solved out of 26 for Base, Synth v1, Phone Number, and Generalized C++*, showing first-test-round and within-two-test-round results

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.

ConfigurationFirst round mean / 26Two rounds mean / 26Conditional recovery
GLM-4.7-Flash base0.50 (1.9%)4.50 (17.3%)16/102 (15.7%)
Luna reference6.25 (24.0%)16.75 (64.4%)42/79 (53.2%)
SFT v56.00 (23.1%)10.25 (39.4%)17/80 (21.2%)
Synth v1, epoch 509.50 (36.5%)12.00 (46.2%)10/66 (15.2%)
Execution-midband RL v18.25 (31.7%)13.00 (50.0%)19/71 (26.8%)
Execution-midband RL v210.50 (40.4%)14.50 (55.8%)16/62 (25.8%)
Phone Number, iter 1411.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.

TaskSynth v1 first-round successesPhone Number first-round successes
Phone Number1 / 44 / 4
Parallel Letter Frequency0 / 43 / 4
Gigasecond3 / 40 / 4
Sublist3 / 41 / 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 decisionsRepeated 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

SettingRecorded value
Base model and adaptationGLM-4.7-Flash; LoRA rank 16, alpha 32.
Training hardware8 × H100 80 GB; BF16; tensor parallel 4; expert parallel 8.
Dispatch and servingDeepEP [12] flex dispatch; SGLang [13] rollout service; Miles [14] training integration.
Rollout and batch8 prompts × 32 samples; global batch 256; 20 GRPO updates.
OptimizationLearning rate 3×10−53 \times10^{-5}; constant schedule; warmup fraction 0.1; KL coefficient 0.1.
GenerationSequence limit 12,288; response limit 8,192; temperature 0.7; thinking enabled.
Warm start and scored checkpointInitial 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 pathDefinition and role
Whole-file execution rewardDefault 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 rewardMean 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 rewardValidated 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 adjustmentA positive shared verification score is retained when required task-specific checks pass. Otherwise use 0.5 min(RsR_s, 0) + 0.5(ft−1f_t - 1). Invalid task-specific evaluations are flagged separately.

Table 8. Experiment-specific reward definitions and roles.

In the adjustment formula, RsR_s denotes the shared verification score and ftf_t 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.

ConfigurationFirst round SD; range; 95% CITwo rounds SD; range; 95% CIRecovery 95% CI
Base0.58; 0-1; 0-1.251.29; 3-6; 2.25-6.757.8-24.8%
Luna1.89; 5-9; 3.25-9.51.50; 15-18; 12.75-20.536.8-70%
SFT v51.63; 4-8; 3-9.251.71; 8-12; 7-13.7511.9-31.6%
Synth v10.58; 9-10; 5.75-13.50.82; 11-13; 8.25-15.757.4-24.4%
Midband RL v12.06; 6-11; 4.75-120.82; 12-14; 9-1714.5-41.4%
Midband RL v21.29; 9-12; 7-142.08; 12-17; 10.5-18.512.9-41.9%
Phone Number0.50; 11-12; 7.5-150.50; 15-16; 11-19.2513.1-44.2%
Generalized C++*1.50; 10-13; 8-15.51.41; 14-17; 11.75-2014.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. [1]Z.ai. 2026. GLM-4.7-Flash. Model card, Hugging Face. https://huggingface.co/zai-org/GLM-4.7-Flash.
  2. [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. [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. [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. [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. [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. [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. [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. [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. [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. [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. [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. [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. [14]Miles Team. 2026. Miles: Enterprise-Grade Reinforcement Learning for Large-Scale Model Post-Training. Computer software. https://github.com/radixark/miles.

Paper details

vlnc:W_97nm8f77
Version
v1 · latest
Published
Fresh — added to the Hub within the last 30 days
Added
License
CC BY 4.0
Usage

views · 0

downloads · 0

A view counts once per browser per day, a download each time the PDF is requested.

  • Computer Science

Codex

View statement
Looking for related papers…
Contents