Pith. sign in

REVIEW 4 major objections 5 minor 1 cited by

MCTS-Refined CoT: High-Quality Fine-Tuning Data for LLM-Based Repository Issue Resolution

T0 review · 4 major / 5 minor · reviewed 2026-08-07 · deepseek-v4-flash

Challenge this review Re-run · record.json Download PDF Read on arXiv ↗

Pith's one-line read Fine-tuning on MCTS-verified chain-of-thought traces lets a 72B open model beat same-scale baselines on SWE-bench issue resolution.

desk verdict Plausible pipeline with good numbers, but the mechanism isn't isolated and the RQ1 conclusion contradicts the table. read the letter →

arxiv 2506.12728 v1 pith:YISOHLK5 submitted 2025-06-15 cs.SE

Yibo Wang , Zhihao Peng , Ying Wang , Zhao Wei , Hai Yu , Zhiliang Zhu This is my paper
classification cs.SE
keywords MCTS-REFINEchain-of-thoughtdataissueresolutionrejectionsamplingsupervisedfine-tuningSWE-benchMonteCarloTreeSearchcoderepair
verification ladder T0 review T1 audit T2 compute T3 formal

The pith

A machine-rendered reading of the paper's core claim, the machinery that carries it, and where it could break.

The reading

The paper claims that the bottleneck for open-source LLMs on repository-level issue resolution is not parameter count but the quality of the chain-of-thought data used to fine-tune them. It proposes MCTS-REFINE, which generates such data by decomposing issue resolution into file localization, fault localization, and patch generation, and accepting a reasoning path only when its intermediate predictions and final patch exactly match the developer's gold patch. A reflection step detects and rewrites flawed steps, so the final 52,068-sample dataset is verified at every stage rather than only at the end. If the claim holds, sub-100B open models can reach the best resolution rates reported for their scale through supervised fine-tuning alone, without proprietary APIs.

What carries the argument

The load-bearing mechanism is an MCTS loop augmented with rejection sampling and reflection, operating over three subtasks with explicit ground truth. File Localization requires predicted file paths to match the developer-modified files; Fault Localization requires identified classes, methods, functions, and global variables to align exactly; Patch Generation requires the generated edits, after normalization that strips comments and whitespace, to match the gold patch exactly. At each expansion, an LLM judge (DeepSeek-V3) scores the reasoning step on a 0-10 scale against ground truth; a UCB policy drives selection; rejection sampling accepts or discards the partial path; a refinement phase asks for Feedback or No-Feedback and rewrites only the faulty step; and backpropagation updates node rewards and visit counts. The process runs up to 50 iterations per instance, and the accepted reasoning paths form the supervised fine-tuning dataset.

What would settle it

Take a random sample of the released CoT dataset and have independent annotators check every intermediate step against the gold patch and the issue semantics; if a substantial fraction of traces contain wrong intermediate reasoning even though the final patch exactly matches, the central quality claim fails. Separately, an ablation that removes the refinement feedback (or replaces it with random feedback) while keeping rejection sampling would show whether the reflection component, rather than the exact-match filter, drives the fine-tuning gains.

Watch

Extended reading notes

Core claim

The central claim, on the paper's terms, is that stepwise ground-truth validation turns Monte Carlo Tree Search into a reliable synthesizer of issue-resolution reasoning data. Fine-tuning Qwen2.5-Coder-7B, Qwen2.5-Coder-32B, and Qwen2.5-72B-Instruct on the resulting dataset gives resolution rates of 16.3% and 22.6%, 25.7% and 32.4%, and 28.3% and 35.0% on SWE-bench Lite and SWE-bench Verified, respectively; the 72B result surpasses the SWE-Fixer-Qwen-72B baseline (24.7% and 32.8%) at the same parameter scale. With exact issue locations supplied, the fine-tuned 72B model reaches 43.8% on Verified, which the paper reports as comparable to DeepSeek-V3. The authors attribute the gains to the rejection-sampling protocol: only reasoning paths whose predicted files, fault locations, and normalized code edits exactly match developer patches are kept, and the reflection mechanism corrects errors before they propagate.

Load-bearing premise

The pipeline trusts that DeepSeek-V3, when shown the issue, the current reasoning path, and the ground truth, reliably assigns rewards and gives corrective feedback; the paper reports no measurement of this judge's accuracy, so the claimed data quality depends on an unverified evaluator.

Editorial extensions

If this is right

  • Fine-tuned Qwen2.5-72B-Instruct reaches 28.3% on SWE-bench Lite and 35.0% on SWE-bench Verified, surpassing the same-scale SWE-Fixer-Qwen-72B baseline (24.7% and 32.8%).
  • Fine-tuned 32B and 7B models also exceed their scale's previous best baselines, with 25.7% and 32.4% and 16.3% and 22.6% on Lite and Verified, respectively.
  • Given exact issue locations, the fine-tuned 72B model reaches 43.8% resolution on Verified, close to the 47.8% reported for DeepSeek-V3.
  • Because the dataset, framework, and fine-tuned models are open-sourced, other teams can reproduce or build on the recipe without relying on proprietary APIs.

Reading between the lines

Editorial extensions of the paper, not claims the author makes directly.

  • A natural test would be ablating the refinement component: if keeping rejection sampling but removing feedback yields comparable fine-tuning gains, then the reflection mechanism is not the real driver.
  • The exact-match sampling criterion may bias the dataset toward patches that are textually close to gold solutions, making models trained this way brittle on issues where many distinct valid patches exist.
  • The same judge-and-refine MCTS loop should transfer to other multi-step software tasks, such as refactoring or test generation, wherever a gold artifact is available for exact checking.
  • The unmeasured judge accuracy could be probed directly: if DeepSeek-V3's 0-10 scores or Feedback/No-Feedback decisions disagree with human judgments on a labeled sample, a separately trained verifier might be a better evaluator.
Share X Bluesky LinkedIn Reddit HN

Editorial analysis

A structured set of objections, weighed in public.

Desk editor's note, referee report, and a circularity audit.

Referee Report

4 major / 5 minor

Summary. The paper proposes MCTS-REFINE, a Monte Carlo Tree Search (MCTS)-based pipeline for generating chain-of-thought (CoT) fine-tuning data for repository-level issue resolution. The method decomposes issue resolution into file localization, fault localization, and patch generation; for each subtask it runs MCTS with an LLM-assigned reward, rejection sampling that requires the generated solution to match developer ground-truth patches, and a refinement step in which the LLM provides corrective feedback on reasoning steps. The authors generate a 52,068-sample dataset from 20k issues using DeepSeek-V3, fine-tune Qwen2.5-Coder 7B/32B/72B-Instruct, and report resolution rates on SWE-bench Lite and Verified, with the 72B model reaching 28.3% and 35.0% on the two benchmarks, and 43.8% on Verified when given gold locations. They release the dataset and fine-tuned models.

Significance. If the headline results hold, the work is significant: it would show that sub-100B open models can reach state-of-the-art issue-resolution levels on SWE-bench with SFT on synthetically generated CoT data, which is practically important for cost- and privacy-constrained settings. The multi-scale evaluation (7B/32B/72B), the use of external SWE-bench benchmarks, and the open release of the dataset and models are concrete strengths. The exact-match rejection sampling against developer patches provides a strong objective filter for final outputs, and the evaluation is not circular because the headline result is measured on the external SWE-bench benchmark. However, the absence of ablations isolating the MCTS-REFINE mechanism, the unmeasured reliability of the LLM judge used for intermediate-step feedback, and an internal inconsistency in the RQ1 conclusion mean that the central mechanism claim is not yet fully supported.

major comments (4)
  1. [§IV-B (RQ1 Conclusion)] The RQ1 Conclusion states that on SWE-bench Verified the models achieve 16.3%, 25.7%, and 28.3% resolution rates, while on SWE-bench Lite they reach 22.6%, 32.4%, and 35.0%. This is the reverse of Table II and the Abstract, which report Verified = 22.6/32.4/35.0 and Lite = 16.3/25.7/28.3 for the 7B/32B/72B models. Because this sentence directly states the paper's headline results, the swap is a load-bearing reporting error that must be corrected.
  2. [§IV-A and §IV-B (no ablation)] No experiment isolates MCTS-REFINE from simpler alternatives. The gains over external baselines could come from exact-match gold-patch filtering, from the choice of DeepSeek-V3 as the generator, or from the 20k-sample curation, rather than from MCTS-based step validation and refinement. An ablation should compare, for the same generator and the same data budget: single-turn CoT with the same per-subtask exact-match filter, SFT on gold patches or gold reasoning without MCTS, and different dataset sizes. Without such an ablation, the central attribution of the improvement to MCTS-REFINE is unsubstantiated.
  3. [§III-B.3 and §III-B.4 (judge accuracy)] The rejection-sampling rules validate only the generated subtask solution (file paths, fault signatures, or patch) against ground truth; they do not validate the intermediate reasoning steps themselves. The refinement phase's Feedback/No-Feedback decision is produced by the same model family (DeepSeek-V3) and no accuracy measurement for this judge is reported. Because the paper's own Figure 1(b) shows that a final patch can exactly match the gold patch while intermediate reasoning is wrong, and because a No-Feedback verdict would admit such a path, the claimed high-quality CoT premise is not established. The authors should measure judge accuracy or otherwise demonstrate that accepted reasoning steps are faithful to the gold solution; the same concern applies to the 0-10 reward scores assigned during Expansion in Section III-B.2.
  4. [Table II (small differences)] Several headline improvements are small in absolute terms relative to benchmark size: for example, the 32B model gains 1.6-1.7 percentage points over SoRFT on Lite and Verified, and the 7B model gains 1.2-2.3 points. No confidence intervals, error bars, or significance tests are reported, so it is unclear whether these differences are robust. The authors should provide such analysis or temper the surpassing-SOTA claims accordingly.
minor comments (5)
  1. [§III-B.3] The term exact match is qualified later by ignoring whitespace, line breaks, and comments; please use normalized exact match consistently in the Abstract and Section III-A.
  2. [§IV-A] The text says the refinement process iterates through six MCTS phases, namely selection, expansion, rejection, sampling, refinement, and backpropagation, but the method defines five phases with rejection sampling as one phase; correct the enumeration.
  3. [Tables III and IV] Model naming is inconsistent: Section IV-A says the fine-tuned models are Qwen2.5-Coder-7B/32B/72B-Instruct, while Tables III and IV use Qwen2.5-7B/32B/72B-Instruct and Qwen2.5-Instruct; unify the names and clarify the base model.
  4. [§IV-D] The claim that 43.8% is comparable to the performance of Deepseek-V3 should specify whether DeepSeek-V3's 47.8% in Table IV was obtained under the identical protocol (given locations plus 20 surrounding lines) or taken from the Agentless paper; otherwise the comparison is ambiguous.
  5. [§III-B and §IV-A] No sensitivity analysis is reported for the MCTS hyperparameters (epsilon=0.5, alpha=0.5, branching factor b=3, maximum iterations T=50) or for the choice of 20k sampled issues from SWE-Fixer-Train-110K; a brief discussion of their influence would strengthen the paper.

Circularity Check

1 steps flagged · score 2.0 of 10

Central SWE-bench result is externally measured and not circular; a minor definitional step equates exact-match filtering with 'correctness across reasoning paths'.

  1. self definitional [Abstract; Section III-B.3 (Rejection Sampling)]
    "Key innovations include: ... (3) enforcing a strict sampling protocol where intermediate outputs must exactly match verified developer patches, ensuring correctness across reasoning paths."

    The paper's dataset-quality claim is defined by its own rejection-sampling criterion: a reasoning path is retained only when the LLM-generated subtask solution (file paths, fault locations, or patch edits) exactly matches the developer gold patch, as stated in Section III-B.3 ('Samples reasoning paths where the generated edits exactly match the ground truth'). The assertion that this protocol 'ensures correctness across reasoning paths' is therefore a restatement of the operational filter rather than an independent verification of the reasoning steps. However, the headline SWE-bench resolution rates are measured on held-out benchmark instances excluded from the training data, so this definitional step does not force the central empirical result.

full rationale

The paper's load-bearing performance claims are evaluated on SWE-bench Lite and Verified, which are external benchmarks explicitly excluded from the CoT training corpus (the paper states it excludes all SWE-bench repositories when collecting training data). Those resolution rates are therefore not forced by construction. The dataset construction does contain a self-definitional element: 'high-quality CoT' is operationalized as CoT whose generated subtask outputs exactly match gold patches, and the abstract's 'ensuring correctness across reasoning paths' is an overstatement of what that filter guarantees. Refinement feedback and reward scores come from DeepSeek-V3 judging against ground truth, and the paper reports no accuracy measurement for this judge, so a correct gold patch could be paired with flawed intermediate reasoning and still be accepted. This is a real limitation in attributing improvements to MCTS-REFINE specifically, but it is a confound/validity concern rather than a circular reduction of the benchmark result. The paper contains no load-bearing self-citations, no imported uniqueness theorems from its own authors, and no renaming of known results as new predictions. Overall circularity is minor and does not undermine the principal empirical finding.

Assumptions & free parameters 8 free parameters · 5 assumptions · 0 invented entities

The central claim depends mostly on domain assumptions about ground-truth quality, LLM judging ability, and leakage control. No unmeasured physical entities are introduced. The method's hyperparameters are standard, but the reliability of the LLM-as-judge is the least validated input and the training corpus selection is not justified by analysis.

free parameters (8)
  • MCTS exploration coefficient epsilon = 0.5
    Set following prior MCTS practice [31]; balances exploration and exploitation, affecting which reasoning nodes are expanded.
  • MCTS branching factor b = 3
    Number of child reasoning steps generated per expansion; adopted convention from prior MCTS literature.
  • Backpropagation weighting alpha = 0.5
    Blends a node's current reward with child-reward increments during backpropagation; chosen by hand.
  • Maximum MCTS iterations T = 50
    Termination bound for refinement; empirically set based on an existing MCTS approach.
  • SFT epochs = 2
    Training duration for all fine-tuned models.
  • Learning rate = 5e-6
    Initial learning rate with cosine decay for supervised fine-tuning.
  • Warmup ratio = 3%
    Training warmup proportion.
  • Training corpus size = 20,000 Issue-PR pairs
    Randomly selected subset of SWE-Fixer-Train-110K to limit compute; no analysis of representativeness is provided.
assumptions (5)
  • domain assumption Gold developer patches are correct and complete ground truth for the three subtasks.
    Every sampling decision and the final patch criterion compare against patches from merged PRs; introduced in Section III-A and used throughout Section III-B.
  • domain assumption SWE-Fixer-Train-110K Issue-PR pairs are high-quality and suitable for CoT synthesis.
    Dataset source from [28] is used without an independent quality audit; described in Section III-C.
  • domain assumption DeepSeek-V3 can reliably score reasoning steps and generate corrective feedback when shown ground truth.
    The reward and refinement phases in Sections III-B.2 and III-B.4 trust the LLM-as-judge without validation.
  • domain assumption Excluding repositories overlapping SWE-bench from training data prevents leakage.
    Stated in Sections III-C and V; assumes repository-name exclusion is sufficient against issue-level overlap.
  • domain assumption SWE-bench test-case pass rate is a valid measure of issue resolution.
    Evaluation metric used throughout Section IV; standard in the field.

how reviews work

0 comments
Cite this review

Pith. "Pith review of MCTS-Refined CoT: High-Quality Fine-Tuning Data for LLM-Based Repository Issue Resolution." pith.science (2026). https://pith.science/paper/YISOHLK5

@misc{pith2026250612728,
  author       = {Pith},
  title        = {Pith review of: MCTS-Refined CoT: High-Quality Fine-Tuning Data for LLM-Based Repository Issue Resolution},
  year         = {2026},
  howpublished = {\url{https://pith.science/paper/YISOHLK5}},
  note         = {Machine review of arXiv:2506.12728}
}
read the original abstract

LLMs demonstrate strong performance in auto-mated software engineering, particularly for code generation and issue resolution. While proprietary models like GPT-4o achieve high benchmarks scores on SWE-bench, their API dependence, cost, and privacy concerns limit adoption. Open-source alternatives offer transparency but underperform in complex tasks, especially sub-100B parameter models. Although quality Chain-of-Thought (CoT) data can enhance reasoning, current methods face two critical flaws: (1) weak rejection sampling reduces data quality, and (2) inadequate step validation causes error accumulation. These limitations lead to flawed reasoning chains that impair LLMs'ability to learn reliable issue resolution. The paper proposes MCTS-REFINE, an enhanced Monte Carlo Tree Search (MCTS)-based algorithm that dynamically validates and optimizes intermediate reasoning steps through a rigorous rejection sampling strategy, generating high-quality CoT data to improve LLM performance in issue resolution tasks. Key innovations include: (1) augmenting MCTS with a reflection mechanism that corrects errors via rejection sampling and refinement, (2) decomposing issue resolution into three subtasks-File Localization, Fault Localization, and Patch Generation-each with clear ground-truth criteria, and (3) enforcing a strict sampling protocol where intermediate outputs must exactly match verified developer patches, ensuring correctness across reasoning paths. Experiments on SWE-bench Lite and SWE-bench Verified demonstrate that LLMs fine-tuned with our CoT dataset achieve substantial improvements over baselines.Notably, Qwen2.5-72B- Instruct achieves 28.3%(Lite) and 35.0%(Verified) resolution rates, surpassing SOTA baseline SWE-Fixer-Qwen-72B with the same parameter scale, which only reached 24.7%(Lite) and 32.8%(Verified).

Figures

Figures reproduced from arXiv: 2506.12728 by the authors.

Figure 1
Figure 1. A illustrative example of defective CoT generated by GPT-4o cv Selection Expansion Rejection Sampling & Refinements Backpropagation Subtask Objective Step1 Nodes S1 UCB=2 UCB=6 UCB=4 UCB=1 UCB=1 UCB=5 Select the Child Node with Highest UCB Value cv Generate Step3 Q = 2 Q = 3 Q = 6 cv cv Update the NodeValues and the Visit Count Exactly Match Feedback with Ground Truth Rejection Sampling Sampling √ Fault Locations Su… view at source ↗
Figure 2
Figure 2. An Overall Architecture of MCTS-REFINE while providing corrective suggestions, and (2) optimizing erroneous steps by incorporating these modifications. To address the complex issue resolution tasks, we adopt the AGENTLESS framework [30] by decomposing the process into three subtasks: File Localization, Fault Localization, and Patch Generation. This structured decomposition enables: (1) clear definition of input-outp… view at source ↗
Figure 3
Figure 3. An illustrative Prompt Template of Expansion Phase for File Localization Subtask This traversal path’s node sequence then provides contextual grounding for the subsequent expansion phase. UCB(S) = QS + ϵ · s ln Nparent NS (1) In this formulation, the reward score QS for node S is assigned by the LLM during node expansion, where Nparent and NS represent the visit counts of the parent node and current node S respectiv… view at source ↗
Figures from the paper (3 more)
Figure 4
Figure 4. Figure 4: An illustrative Prompt Template of Refinement Phase for File Localization Subtask (1) assessing the alignment between the reasoning path and ground truth, and (2) generating specific corrective suggestions for identified deviations [PITH_FULL_IMAGE:figures/full_fig_p0…
Figure 5
Figure 5. Figure 5: Comparison of issue resolution rates across baselines GPT-4o Claude-3.5-Sonnet MCTS-Refine 72B MCTS-Refine 32B MCTS-Refine 7B 5 2 4 4 4 7 49 12 9 36 0 12 31 4 2 13 0 0 16 10 14 17 9 32 2 2 2 2 2 7 11 [PITH_FULL_IMAGE:figures/full_fig_p009_5.png]
Figure 6
Figure 6. Figure 6: A Venn diagram examining the overlap of solved instances among different models on the SWE-bench Verified benchmark LoRA with full-parameter fine-tuning on our CoT dataset could further improve the model’s issue resolution capability. Conclusion: Our 7B, 32B, and 72B m…

Discussion (0). Sign in to comment.

Forward citations

Cited by 1 Pith paper

Reviewed papers in the Pith corpus that reference this work. Sorted by Pith novelty score. Full citation record

  1. From Historical Patches to Repair Plans: Outcome-Conditioned Reasoning for Repository-Level Program Repair

    cs.SE 2026-01 conditional novelty 6.0 of 10

    Backward reasoning distilled from a repository's already-fixed issues, injected as prompts, lifts LLM repair success on SWE-Bench Lite by up to 10.4 Pass@1 points.

Reference graph

Works this paper leans on

42 extracted references · 17 canonical work pages · cited by 1 Pith paper

  1. [1]

    Fan A, Gokkaya B, Harman M, et al. Large language models for software engineering: Survey and open problems[C]//2023 IEEE/ACM International Conference on Software Engineering: Future of Software Engineering (ICSE-FoSE). IEEE, 2023: 31-53

    work page 2023

  2. [2]

    Large language models for software engineering: A systematic literature review[J]

    Hou X, Zhao Y , Liu Y , et al. Large language models for software engineering: A systematic literature review[J]. ACM Transactions on Software Engineering and Methodology, 2024, 33(8): 1-79

    work page 2024

  3. [3]

    Software testing with large language models: Survey, landscape, and vision[J]

    Wang J, Huang Y , Chen C, et al. Software testing with large language models: Survey, landscape, and vision[J]. IEEE Transactions on Soft- ware Engineering, 2024

    work page 2024

  4. [4]

    Deepseek-v3 technical report[J]

    Liu A, Feng B, Xue B, et al. Deepseek-v3 technical report[J]. arXiv preprint arXiv:2412.19437, 2024

    arXiv 2024

  5. [5]

    DeepSeek-Coder: When the Large Language Model Meets Programming–The Rise of Code Intelligence[J]

    Guo D, Zhu Q, Yang D, et al. DeepSeek-Coder: When the Large Language Model Meets Programming–The Rise of Code Intelligence[J]. arXiv preprint arXiv:2401.14196, 2024

    arXiv 2024

  6. [6]

    Code llama: Open foundation models for code[J]

    Roziere B, Gehring J, Gloeckle F, et al. Code llama: Open foundation models for code[J]. arXiv preprint arXiv:2308.12950, 2023

    arXiv 2023

  7. [7]

    An Empirical Study on the Code Refactoring Capability of Large Language Models[J]

    Cordeiro J, Noei S, Zou Y . An Empirical Study on the Code Refactoring Capability of Large Language Models[J]. arXiv preprint arXiv:2411.02320, 2024

    arXiv 2024

  8. [8]

    OpenAI. 2024. Introducing GPT-4o. https://openai.com/index/hello-gpt- 4o/

    work page 2024

Show all 42 references
  1. [9]

    Anthropic. 2024. Introducing Claude 3.5 Sonnet. https://www.anthropic.com/news/claude-3-5-sonnet

    2024

  2. [10]

    The llama 3 herd of models[J]

    Grattafiori A, Dubey A, Jauhri A, et al. The llama 3 herd of models[J]. arXiv preprint arXiv:2407.21783, 2024

    2024 arXiv

  3. [11]

    Swe-bench: Can language models resolve real-world github issues?[J]

    Jimenez C E, Yang J, Wettig A, et al. Swe-bench: Can language models resolve real-world github issues?[J]. arXiv preprint arXiv:2310.06770, 2023

    2023 arXiv

  4. [12]

    Chain-of-thought in neural code gener- ation: From and for lightweight language models[J]

    Yang G, Zhou Y , Chen X, et al. Chain-of-thought in neural code gener- ation: From and for lightweight language models[J]. IEEE Transactions on Software Engineering, 2024

    2024

  5. [13]

    Structured chain-of-thought prompting for code generation[J]

    Li J, Li G, Li Y , et al. Structured chain-of-thought prompting for code generation[J]. ACM Transactions on Software Engineering and Methodology, 2025, 34(2): 1-23

    2025

  6. [14]

    Recursive introspection: Teaching language model agents how to self-improve[J]

    Qu Y , Zhang T, Garg N, et al. Recursive introspection: Teaching language model agents how to self-improve[J]. Advances in Neural Information Processing Systems, 2024, 37: 55249-55285

    2024

  7. [15]

    RealCritic: Towards Effectiveness- Driven Evaluation of Language Model Critiques[J]

    Tang Z, Li Z, Xiao Z, et al. RealCritic: Towards Effectiveness- Driven Evaluation of Language Model Critiques[J]. arXiv preprint arXiv:2501.14492, 2025

    2025 arXiv

  8. [16]

    Instruction tuning for large language models: A survey[J]

    Zhang S, Dong L, Li X, et al. Instruction tuning for large language models: A survey[J]. arXiv preprint arXiv:2308.10792, 2023

    2023

  9. [17]

    Deepseek-r1: Incentivizing reason- ing capability in llms via reinforcement learning[J]

    Guo D, Yang D, Zhang H, et al. Deepseek-r1: Incentivizing reason- ing capability in llms via reinforcement learning[J]. arXiv preprint arXiv:2501.12948, 2025

    2025 arXiv

  10. [18]

    Rest-mcts*: Llm self-training via process reward guided tree search[J]

    Zhang D, Zhoubian S, Hu Z, et al. Rest-mcts*: Llm self-training via process reward guided tree search[J]. Advances in Neural Information Processing Systems, 2024, 37: 64735-64772

    2024

  11. [20]

    rStar-Math: Small LLMs Can Master Math Reasoning with Self-Evolved Deep Thinking[J]

    Guan X, Zhang L L, Liu Y , et al. rStar-Math: Small LLMs Can Master Math Reasoning with Self-Evolved Deep Thinking[J]. arXiv preprint arXiv:2501.04519, 2025

    2025 arXiv

  12. [21]

    Towards reasoning era: A survey of long chain-of-thought for reasoning large language models

    Chen Q, Qin L, Liu J, et al. Towards reasoning era: A survey of long chain-of-thought for reasoning large language models. arXiv preprint arXiv:2503.09567, 2025

    2025 arXiv

  13. [22]

    Hui B, Yang J, Cui Z, et al. Qwen2. 5-coder technical report[J]. arXiv preprint arXiv:2409.12186, 2024

    2024 arXiv

  14. [23]

    Lingma SWE-GPT: An open development- process-centric language model for automated software improvement

    Ma Y , Cao R, Cao Y , et al. Lingma SWE-GPT: An open development- process-centric language model for automated software improvement. The ACM SIGSOFT International Symposium on Software Testing and Analysis (ISSTA 2025), 2025

    2025

  15. [24]

    Swe-agent: Agent-computer interfaces enable automated software engineering[J]

    Yang J, Jimenez C E, Wettig A, et al. Swe-agent: Agent-computer interfaces enable automated software engineering[J]. Advances in Neural Information Processing Systems, 2024, 37: 50528-50652

    2024

  16. [25]

    Sorft: Issue resolving with subtask-oriented reinforced fine-tuning

    Ma Z, Peng C, Gao P, et al. Sorft: Issue resolving with subtask-oriented reinforced fine-tuning. arXiv preprint arXiv:2502.20127, 2025

    2025 arXiv

  17. [26]

    Swe-rl: Advancing llm reasoning via reinforcement learning on open software evolution

    Wei Y , Duchenne O, Copet J, et al. Swe-rl: Advancing llm reasoning via reinforcement learning on open software evolution. arXiv preprint arXiv:2502.18449, 2025

    2025 arXiv

  18. [27]

    Training Software Engineering Agents and Verifiers with SWE-Gym

    Pan, J., Wang, X., Neubig, G., Jaitly, N., Ji, H., Suhr, A., & Zhang, Y . Training Software Engineering Agents and Verifiers with SWE-Gym. arXiv preprint arXiv:2412.21139

    arXiv

  19. [28]

    SWE- Fixer: Training Open-Source LLMs for Effective and Efficient GitHub Issue Resolution

    Xie, C., Li, B., Gao, C., Du, H., Lam, W., Zou, D., & Chen, K. SWE- Fixer: Training Open-Source LLMs for Effective and Efficient GitHub Issue Resolution. arXiv preprint arXiv:2501.05040

    arXiv

  20. [29]

    RethinkMCTS: Refining Erroneous Thoughts in Monte Carlo Tree Search for Code Generation[J]

    Li Q, Xia W, Du K, et al. RethinkMCTS: Refining Erroneous Thoughts in Monte Carlo Tree Search for Code Generation[J]. arXiv preprint arXiv:2409.09584, 2024

    2024

  21. [30]

    S., Deng, Y ., Dunn, S., & Zhang, L

    Xia, C. S., Deng, Y ., Dunn, S., & Zhang, L. (2024). Agentless: Demystifying llm-based software engineering agents. arXiv preprint arXiv:2407.01489

    2024 arXiv

  22. [31]

    Rest-mcts: Llm self-training via process reward guided tree search[J]

    Zhang D, Zhoubian S, Hu Z, et al. Rest-mcts: Llm self-training via process reward guided tree search[J]. Advances in Neural Information Processing Systems, 2024, 37: 64735-64772

    2024

  23. [32]

    Swe-agent: Agent-computer interfaces enable automated software engineering

    Yang J, Jimenez C E, Wettig A, et al. Swe-agent: Agent-computer interfaces enable automated software engineering. Advances in Neural Information Processing Systems, 2024, 37: 50528-50652

    2024

  24. [33]

    Openhands: An open platform for ai software developers as generalist agents.//The Thirteenth International Conference on Learning Representations

    fWang X, Li B, Song Y , et al. Openhands: An open platform for ai software developers as generalist agents.//The Thirteenth International Conference on Learning Representations. 2024

    2024

  25. [34]

    Repository Structure-Aware Training Makes SLMs Better Issue Resolver

    Ma Z, An S, Lin Z, et al. Repository Structure-Aware Training Makes SLMs Better Issue Resolver. arXiv preprint arXiv:2412.19031, 2024

    2024 arXiv

  26. [35]

    Bridging Bug Localization and Issue Fixing: A Hierarchical Localization Framework Leveraging Large Language Models[J]

    Chang J, Zhou X, Wang L, et al. Bridging Bug Localization and Issue Fixing: A Hierarchical Localization Framework Leveraging Large Language Models[J]. arXiv preprint arXiv:2502.15292, 2025

    2025 arXiv

  27. [36]

    Openmathinstruct-2: Accelerating ai for math with massive open-source instruction data[J]

    Toshniwal S, Du W, Moshkov I, et al. Openmathinstruct-2: Accelerating ai for math with massive open-source instruction data[J]. arXiv preprint arXiv:2410.01560, 2024

    2024 arXiv

  28. [37]

    Rephrasing the web: A recipe for compute and data-efficient language modeling[J]

    Maini P, Seto S, Bai H, et al. Rephrasing the web: A recipe for compute and data-efficient language modeling[J]. arXiv preprint arXiv:2401.16380, 2024

    2024 arXiv

  29. [38]

    A survey on data synthesis and augmen- tation for large language models[J]

    Wang K, Zhu J, Ren M, et al. A survey on data synthesis and augmen- tation for large language models[J]. arXiv preprint arXiv:2410.12896, 2024. 11

    2024 arXiv

  30. [39]

    Impact of code language models on automated program repair[C]//2023 IEEE/ACM 45th International Conference on Software Engineering (ICSE)

    Jiang N, Liu K, Lutellier T, et al. Impact of code language models on automated program repair[C]//2023 IEEE/ACM 45th International Conference on Software Engineering (ICSE). IEEE, 2023: 1430-1442

    2023

  31. [40]

    An empirical evaluation of using large language models for automated unit test generation[J]

    Schäfer M, Nadi S, Eghbali A, et al. An empirical evaluation of using large language models for automated unit test generation[J]. IEEE Transactions on Software Engineering, 2023, 50(1): 85-105

    2023

  32. [41]

    Llamafactory: Unified efficient fine- tuning of 100+ language models[J]

    Zheng Y , Zhang R, Zhang J, et al. Llamafactory: Unified efficient fine- tuning of 100+ language models[J]. arXiv preprint arXiv:2403.13372, 2024

    2024 arXiv

  33. [42]

    Lora: Low-rank adaptation of large language models[J]

    Hu E J, Shen Y , Wallis P, et al. Lora: Low-rank adaptation of large language models[J]. ICLR, 2022, 1(2): 3

    2022

  34. [43]

    A comparative study between full-parameter and lora-based fine-tuning on chinese instruction data for instruction following large language model[J]

    Sun X, Ji Y , Ma B, et al. A comparative study between full-parameter and lora-based fine-tuning on chinese instruction data for instruction following large language model[J]. arXiv preprint arXiv:2304.08109, 2023. 12

    2023 arXiv

Pith tools

Reviewed August 7, 2026 · model on record in the stance chip above.