Pith. sign in

REVIEW 4 major objections 6 minor 36 references

Seed-CTS: Unleashing the Power of Tree Search for Superior Performance in Competitive Coding Tasks

T0 review · 4 major / 6 minor · reviewed 2026-08-11 · deepseek-v4-flash

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

Pith's one-line read Seed-CTS claims that token-level Monte Carlo Tree Search plus Chain-of-Thought prompting lets a 32B open-source code model reach 0.351 on LiveCodeBench-Hard, beating GPT-4o's pass@100 and approaching O1-Mini's pass@1.

desk verdict The headline result is confounded by public-test reward and an unmatched generation budget, though the method and ablations are worth a serious look. read the letter →

arxiv 2412.12544 v2 pith:6SNC6VUA submitted 2024-12-17 cs.AI cs.SE

Hao Wang , Boyi Liu , Yufeng Zhang , Jie Chen This is my paper · ORCID
classification cs.AIcs.SE
keywords token-levelMonteCarloTreeSearchcompetitiveprogrammingcodegenerationchain-of-thoughtpromptingLiveBenchopen-sourcelanguagemodelstest-timepass@k
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 sets out to show that a mid-sized open-source code model, when paired with token-level tree search, can match or beat much larger proprietary models on competition-level coding problems. Its method, Seed-CTS, grows a search tree one token at a time, scores complete programs against the problem's public test cases, and folds Chain-of-Thought planning into the rollout. On LiveCodeBench-Hard, Qwen2.5-Coder-32B-Instruct reaches 0.305, above GPT-4o's pass@100 of 0.245, and with CoT reaches 0.351, near O1-Mini's pass@1 of 0.366. If these comparisons hold under a fair cost accounting, the result suggests that search can substitute for model scale in hard coding tasks, and that the searched solutions could become training data for the same model.

What carries the argument

The machinery is a token-level Monte Carlo Tree Search: each tree node is a candidate token, expansion creates the top-k next tokens from the model's distribution, and a rollout continues to a complete program whose score is either the hard pass/fail on the public tests or the partial pass rate. Selection follows a P-UCB formula that balances the average reward, visit-count exploration, and the model's prior token probability. The CoT variant inserts a planning phase before code generation in the rollout, so the search refines both the plan and the code.

What would settle it

Run the same token-level MCTS on LiveCodeBench-Hard with the public test outputs hidden from the reward (e.g., scoring rollouts on a separate validation split), or count every LLM forward pass used in expansion and rollout; if the pass rate falls to the generator's pass@k level or the per-pass advantage disappears, the reported gains come from test-case filtering rather than from tree search structure.

Watch

Extended reading notes

Core claim

The central discovery is that treating code generation as a token-level search problem converts repeated sampling into structured exploration that outperforms best-of-N from the same generator. With max_rollouts=64, MCTS with Qwen2.5-Coder-32B-Instruct scores 0.305 on LiveCodeBench-Hard, against the model's own pass@100 of 0.197 and GPT-4o's 0.245; adding a two-step CoT prompt (plan then code) raises the score to 0.351, approaching O1-Mini's pass@1 of 0.366. The paper also reports that the improvement appears across four model sizes (6.7B to 32B) and that the best search paths, when appended to the prompt, improve ordinary sampling, indicating the search is finding reusable reasoning plans.

Load-bearing premise

The comparison is fair only if counting complete program generations captures the true computational cost, and only if the public test cases used as search rewards do not give MCTS an information advantage that pass@k baselines lack.

Editorial extensions

If this is right

  • A 32B open-source model with token-level MCTS can exceed the pass@100 of GPT-4o on LiveCodeBench-Hard (0.305 vs 0.245), and with CoT reaches 0.351, just 0.015 below O1-Mini's pass@1.
  • The search is model-agnostic: at max_rollouts=32, DeepSeekCoder-6.7B-Instruct reaches 0.205 on the hard subset, matching Qwen2.5-72B-Instruct-api's pass@100 of 0.212.
  • MCTS uses fewer complete generations than the pass@k baselines it beats (for example, about 68 mean generations at rollouts=16 on hard), suggesting efficiency rather than brute-force sampling.
  • Best paths found by search improve plain pass@k when inserted into the prompt (up to 25.5% relative at k=1), so the search discovers reusable plans, not just code.
  • The method can generate high-quality solutions directly from the target model, making it a source of SFT data for competition-level problems.

Reading between the lines

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

  • The efficiency story depends on how costs are counted: the paper compares mean complete generations, while token-level expansion and rollouts consume many additional forward passes, and the search sees public test outputs during search while pass@k baselines do not; a stricter budget or a reward that hides test outputs would test whether the search structure itself, rather than test-case filtering
  • If the gains survive a fairer accounting, token-level tree search could shift the practical frontier of coding models toward smaller open weights, since 32B-class models would need no proprietary API for hard problems.
  • The prompt-amplification result suggests an amortization strategy the paper does not develop: run the search once per problem to extract a plan path, then sample code from that plan cheaply; this is testable and could cut search cost by an order of magnitude.
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 / 6 minor

Summary. The paper proposes Seed-CTS, a token-level Monte Carlo Tree Search (MCTS) method for competition-level code generation. The policy is an open-weight instruct model, expansion uses the top-k most probable next tokens, selection uses a P-UCB score, and simulation rewards are computed by running generated code on public test cases (hard reward and partial reward, Eqs. 9--10). On LiveCodeBench-Hard, direct prompting with Qwen2.5-Coder-32B-Instruct reports a pass rate of 0.305, and CoT prompting raises this to 0.351, compared with pass@100 = 0.245 for GPT4o-0513 and pass@1 = 0.366 for O1-Mini. The paper also reports model-agnostic results across four model sizes and a CodeContest-Test experiment. The authors explicitly report mean numbers of generations per problem as a reproducibility measure.

Significance. If the reported gains survive a matched-budget comparison against a Best-of-N baseline that receives the same public-test feedback, the result would be significant: it would demonstrate that a 32B open-weight model combined with token-level tree search can rival much larger proprietary systems on hard competitive coding, and it would suggest a practical route for synthesizing SFT data from a target model itself. The paper is transparent in reporting mean generation counts and evaluates across multiple base models and two benchmarks, which are welcome practices. The current evidence, however, does not yet isolate the contribution of tree search from the public-test reward signal or from the larger effective sample budget, so the central claim requires additional controlled experiments.

major comments (4)
  1. [§4.1, Tables 1--4; §3.2, Eqs. (9)--(10)] The reported gains of MCTS over pass@k baselines are confounded by the public-test reward. Equations (9) and (10) define the simulation reward using the public test set, while the pass@k baselines in Tables 1 and 3 generate k independent programs and evaluate only on private tests. A Best-of-N baseline that generates N samples and filters or selects them using the same public-test signal must be included before the improvement can be attributed to tree search rather than to test-time filtering. Without this control, the central claim in the abstract is not supported.
  2. [§4.1, Table 4; Figure 3] The headline comparisons are not budget-matched. In Table 4, the direct-prompting pass rate of 0.305 at max_rollouts=64 uses mean generations 241.9, and the CoT pass rate of 0.351 uses 228.7; both exceed the 100 samples used for the pass@100 baselines. At max_rollouts=16, where mean generations are 68.2 and the direct-prompting pass rate is 0.212, the method is below GPT4o-0513's pass@100 of 0.245. The cross-model comparisons should be restated at matched sample counts or with an explicit sample-efficiency curve.
  3. [§3.2, Eqs. (5)--(7); §4.1, Figure 3(d)] The reported 'mean generations' metric counts complete program simulations only. Token-level expansion (Eq. 7) and P-UCB selection (Eq. 5) require additional LLM forward passes per expanded node, so the total LLM compute is undercounted in Figures 2(d), 3(d), and the efficiency claims in Section 4.4. Please report total forward passes or provide a bound on the expansion overhead; otherwise the efficiency comparison against pass@k sampling is unfair.
  4. [§4.3, Figure 6] The interpretive experiment in Section 4.3 does not isolate the contribution of the selection phase. The 'best paths' inserted into the prompt were discovered using the public-test reward during MCTS, so the improved pass@k rates in Figure 6 may reflect leakage of public-test information into the prompt rather than the value of the P-UCB path structure. A control that inserts a path sampled without public-test feedback is needed before concluding that the selection and expansion phases are responsible for the gains.
minor comments (6)
  1. [Figure 7 caption vs. §4.4] The Figure 7 caption reports max_rollouts=16 for the CodeContest experiment, while Section 4.4 states that max_rollouts=32; please correct this inconsistency.
  2. [§4.1, Hard Level paragraph] The text says both DeepSeekCoder-6.7B-Instruct and Qwen2.5-7B-Instruct exhibit pass@100 rates below 10; since the numbers in Table 3 are 0.080 and 0.099, this should read 'below 0.10' or 'below 10%'.
  3. [§3.2, Eqs. (9)--(10) and Eq. (2)] The reward equations use T to denote the test set, which is ambiguous because Eq. (2) defines T = Tpub ∪ Tpriv; the text should state explicitly that only Tpub is used during search.
  4. [Figure 1 caption] The caption contains a typo: 'it's own pass@100 rates' should be 'its own pass@100 rates'.
  5. [Contributions, bullet 1] The contribution bullet says 'Cot Prompting' but should be 'CoT Prompting' for consistency with the rest of the paper.
  6. [References] The reference list has inconsistent formatting (e.g., some entries lack venues or year disambiguation, and two distinct Shinn et al. entries are nearly identical); please unify the bibliography style.

Circularity Check

1 steps flagged · score 3.0 of 10

Central benchmark claims are empirical and not circular; the Section 4.3 'Deep Insight' ablation is a fitted-input-called-prediction because the 'best paths' are selected using the public-test reward (Eq. 10) on the same LiveCodeBench-Hard problems whose pass@k is then reported.

  1. fitted input called prediction [Section 4.3 (Deep Insight into MCTS's Selection Phase), Figure 6; reward definition in Section 3.2, Eq. (10)]
    "Normally, we use all public test cases to validate the generated code... R^{PR}_{s'} = 1/|T| Σ_{(x,y)∈T} 1(Exec(C,x)=y). (10) ... Using the LiveCodeBench-Hard dataset with Qwen2.5-14B-Instruct, we fix max_rollouts = 16 and record the best paths discovered by MCTS. We the modify the prompt for each problem to include the format prompt + best path and employ standard autoregressive decoding methods to sample and compute pass@k rates."

    The 'best paths' recorded in Section 4.3 are selected by the simulation reward of Eq. (10), i.e., by the pass rate on the public test cases of the very LiveCodeBench-Hard problems whose pass@k is then computed in Figure 6. Inserting those paths into the prompt means the modified-prompt pass@k is no longer an independent measurement of the selection phase: the prompt already contains a solution outline chosen using the target problem's test signal. The reported improvement (e.g., +25.5% at K=1) is therefore partly forced by construction, because the fitted path encodes the answer signal that the pass@k evaluation is supposed to probe.

full rationale

The paper's main claims (Sections 4.1 and 4.2) are empirical comparisons against external baselines on LiveCodeBench-Hard and CodeContest-Test, with per-problem mean generation counts reported; no fitted parameter is renamed as a prediction, and no load-bearing self-citation or imported uniqueness theorem is used. The MCTS reward does use public test cases (Eq. 9-10), which is an information advantage over pass@k baselines rather than a circular derivation, though it confounds budget-matched efficiency comparisons. The one genuinely circular step is the Section 4.3 ablation: the 'best paths' are fitted to the benchmark's public tests via the Eq. (10) reward, then the same benchmark's pass@k is measured with those paths embedded in the prompt, so the attribution of improvement to the selection phase reduces, at least in part, to feeding the evaluation signal into the input. Because this circular step is confined to an interpretability ablation and does not support the paper's headline benchmark results, the overall circularity score is modest.

Assumptions & free parameters 4 free parameters · 4 assumptions · 0 invented entities

The method's central claims rest on several hand-chosen hyperparameters and domain assumptions about token-level search and public-test rewards, but it introduces no new physical or conceptual entities. The exploration constants and reward type are particularly under-specified, making exact reproduction difficult.

free parameters (4)
  • P-UCB exploration constants cbase and c = not reported
    Hyperparameters in the P-UCB selection formula (Equations 5 and 6), chosen by hand; the paper never states their values.
  • expansion width k = 5
    Number of child tokens expanded per node, stated as 5 in Section 4.
  • simulation sampling parameters = temperature=0.7, top_p=0.8, repetition_penalty=1.05
    Parameters for the rollout policy, given in Section 4.
  • reward type (HR vs PR) = not stated for main results
    The paper defines hard reward (HR) and partial reward (PR) but does not clearly state which one produces the headline pass rates in Tables 2 and 4.
assumptions (4)
  • domain assumption Token-level actions are a suitable search space for code generation.
    The method searches over next tokens using the LLM's token probabilities; the paper provides no comparative evidence that token-level search is better than plan-level or program-level search.
  • domain assumption Public test cases are a valid reward signal for guiding the search.
    The simulation phase scores rollouts against all public test cases (Equations 9 and 10); this assumes public-test success correlates with private-test success and that using this signal during search is a fair comparison against pass@k baselines.
  • domain assumption The LLM's token probability distribution provides useful priors for P-UCB.
    The prior p(a|s) in the P-UCB formula is taken from the LLM's softmax; if these probabilities are miscalibrated, the search guidance degrades.
  • domain assumption Chain-of-thought planning (plan then code) improves solution correctness for competition tasks.
    CoT prompting is added to the search, but the paper's own CoT example in Section 3.2 generates an exponential algorithm, suggesting the plan is not always sound.

how reviews work

0 comments
Cite this review

Pith. "Pith review of Seed-CTS: Unleashing the Power of Tree Search for Superior Performance in Competitive Coding Tasks." pith.science (2026). https://pith.science/paper/6SNC6VUA

@misc{pith2026241212544,
  author       = {Pith},
  title        = {Pith review of: Seed-CTS: Unleashing the Power of Tree Search for Superior Performance in Competitive Coding Tasks},
  year         = {2026},
  howpublished = {\url{https://pith.science/paper/6SNC6VUA}},
  note         = {Machine review of arXiv:2412.12544}
}
read the original abstract

Competition-level code generation tasks pose significant challenges for current state-of-the-art large language models (LLMs). For example, on the LiveCodeBench-Hard dataset, models such as O1-Mini and O1-Preview achieve pass@1 rates of only 0.366 and 0.143, respectively. While tree search techniques have proven effective in domains like mathematics and general coding, their potential in competition-level code generation remains under-explored. In this work, we propose a novel token-level tree search method specifically designed for code generation. Leveraging Qwen2.5-Coder-32B-Instruct, our approach achieves a pass rate of 0.305 on LiveCodeBench-Hard, surpassing the pass@100 performance of GPT4o-0513 (0.245). Furthermore, by integrating Chain-of-Thought (CoT) prompting, we improve our method's performance to 0.351, approaching O1-Mini's pass@1 rate. To ensure reproducibility, we report the average number of generations required per problem by our tree search method on the test set. Our findings underscore the potential of tree search to significantly enhance performance on competition-level code generation tasks. This opens up new possibilities for large-scale synthesis of challenging code problems supervised fine-tuning (SFT) data, advancing competition-level code generation tasks.

Figures

Figures reproduced from arXiv: 2412.12544 by the authors.

Figure 1
Figure 1. Pass rates of MCTS with DeepSeekCoder-6.7B-Instruct and Qwen2.5-32B-Instruct on [PITH_FULL_IMAGE:figures/full_fig_p002_1.png] view at source ↗
Figure 2
Figure 2. Results on LiveCodeBench-Medium: (a) Comparison of the pass rates of MCTS with [PITH_FULL_IMAGE:figures/full_fig_p007_2.png] view at source ↗
Figure 3
Figure 3. Results on LiveCodeBench-Hard: (a) Comparison of the pass rates of MCTS with different [PITH_FULL_IMAGE:figures/full_fig_p008_3.png] view at source ↗
Figures from the paper (4 more)
Figure 4
Figure 4. Figure 4: When different models are used as the generating model for MCTS, the pass rates of MCTS [PITH_FULL_IMAGE:figures/full_fig_p009_4.png]
Figure 5
Figure 5. Figure 5: To ensure fairness in comparison with the pass@100 rates, we also recorded the average [PITH_FULL_IMAGE:figures/full_fig_p009_5.png]
Figure 6
Figure 6. Figure 6: A comparison between the original prompts from LiveCodeBench-Hard and the modified [PITH_FULL_IMAGE:figures/full_fig_p010_6.png]
Figure 7
Figure 7. Figure 7: Evaluation results on CodeContest_Test. MCTS with [PITH_FULL_IMAGE:figures/full_fig_p011_7.png]

Discussion (0). Continue with ORCID to comment.

Reference graph

Works this paper leans on

36 extracted references · 9 canonical work pages

  1. [1]

    Chen, M., Tworek, J., Jun, H., Yuan, Q., Pinto, H. P. D. O., Kaplan, J., Edwards, H., Burda, Y., Joseph, N., Brockman, G., et al. (2021). Evaluating large language models trained on code. arXiv preprint arXiv:2107.03374

    arXiv 2021

  2. [2]

    Brown, T. B. (2020). Language models are few-shot learners. arXiv preprint arXiv:2005.14165

    arXiv 2020

  3. [3]

    Luo, Z., Xu, C., Zhao, P., Sun, Q., Geng, X., Hu, W., Tao, C., Ma, J., Lin, Q., Jiang, D. (2023). Wizardcoder: Empowering code large language models with evol-instruct. arXiv preprint arXiv:2306.08568

    arXiv 2023

  4. [4]

    Zheng, Q., Xia, X., Zou, X., Dong, Y., Wang, S., Xue, Y., Shen, L., Wang, Z., Wang, A., Li, Y., et al. (2023). Codegeex: A pre-trained model for code generation with multilingual benchmarking on humaneval-x. In Proceedings of the 29th ACM SIGKDD Conference on Knowledge Discovery and Data Mining (pp. 5673--5684)

    work page 2023

  5. [5]

    Li, Y., Choi, D., Chung, J., Kushman, N., Schrittwieser, J., Leblond, R., Eccles, T., Keeling, J., Gimeno, F., Dal Lago, A., et al. (2022). Competition-level code generation with alphacode. Science, 378(6624), 1092--1097

    work page 2022

  6. [6]

    K., et al

    Guo, D., Zhu, Q., Yang, D., Xie, Z., Dong, K., Zhang, W., Chen, G., Bi, X., Wu, Y., Li, Y. K., et al. (2024). DeepSeek-Coder: When the Large Language Model Meets Programming--The Rise of Code Intelligence. arXiv preprint arXiv:2401.14196

    arXiv 2024

  7. [7]

    Hui, B., Yang, J., Cui, Z., Yang, J., Liu, D., Zhang, L., Liu, T., Zhang, J., Yu, B., Lu, K., et al. (2024). Qwen2. 5-coder technical report. arXiv preprint arXiv:2409.12186

    arXiv 2024

  8. [8]

    B., Zi, Y., Muennighoff, N., Kocetkov, D., Mou, C., Marone, M., Akiki, C., Li, J., Chim, J., et al

    Li, R., Allal, L. B., Zi, Y., Muennighoff, N., Kocetkov, D., Mou, C., Marone, M., Akiki, C., Li, J., Chim, J., et al. (2023). Starcoder: may the source be with you!. arXiv preprint arXiv:2305.06161

    arXiv 2023

Show all 36 references
  1. [9]

    E., Adi, Y., Liu, J., Sauvestre, R., Remez, T., et al

    Roziere, B., Gehring, J., Gloeckle, F., Sootla, S., Gat, I., Tan, X. E., Adi, Y., Liu, J., Sauvestre, R., Remez, T., et al. (2023). Code llama: Open foundation models for code. arXiv preprint arXiv:2308.12950

    2023 arXiv

  2. [10]

    L., Almeida, D., Altenschmidt, J., Altman, S., Anadkat, S., et al

    Achiam, J., Adler, S., Agarwal, S., Ahmad, L., Akkaya, I., Aleman, F. L., Almeida, D., Altenschmidt, J., Altman, S., Anadkat, S., et al. (2023). Gpt-4 technical report. arXiv preprint arXiv:2303.08774

    2023 arXiv

  3. [11]

    Shinn, N., Cassano, F., Gopinath, A., Narasimhan, K., Yao, S. (2024). Reflexion: Language agents with verbal reinforcement learning. Advances in Neural Information Processing Systems, 36

    2024

  4. [12]

    Yao, S., Zhao, J., Yu, D., Du, N., Shafran, I., Narasimhan, K., Cao, Y. (2022). React: Synergizing reasoning and acting in language models. arXiv preprint arXiv:2210.03629

    2022 arXiv

  5. [13]

    M., Luck, M., Cui, H

    Huang, D., Bu, Q., Zhang, J. M., Luck, M., Cui, H. (2023). Agentcoder: Multi-agent-based code generation with iterative testing and optimisation. arXiv preprint arXiv:2312.13010

    2023 arXiv

  6. [14]

    Hong, S., Zheng, X., Chen, J., Cheng, Y., Wang, J., Zhang, C., Wang, Z., Yau, S. K. S., Lin, Z., Zhou, L., et al. (2023). Metagpt: Meta programming for multi-agent collaborative framework. arXiv preprint arXiv:2308.00352

    2023 arXiv

  7. [15]

    Wang, X., Chen, Y., Yuan, L., Zhang, Y., Li, Y., Peng, H., Ji, H. (2024). Executable code actions elicit better llm agents. arXiv preprint arXiv:2402.01030

    2024 arXiv

  8. [16]

    Zhang, Y., Ruan, H., Fan, Z., Roychoudhury, A. (2024). Autocoderover: Autonomous program improvement. In Proceedings of the 33rd ACM SIGSOFT International Symposium on Software Testing and Analysis (pp. 1592--1604)

    2024

  9. [17]

    B., Gan, C

    Zhang, S., Chen, Z., Shen, Y., Ding, M., Tenenbaum, J. B., Gan, C. (2023). Planning with large language models for code generation. arXiv preprint arXiv:2303.05510

    2023 arXiv

  10. [18]

    V., Zhou, D., et al

    Wei, J., Wang, X., Schuurmans, D., Bosma, M., Xia, F., Chi, E., Le, Q. V., Zhou, D., et al. (2022). Chain-of-thought prompting elicits reasoning in large language models. Advances in neural information processing systems, 35, 24824--24837

    2022

  11. [19]

    Wang, X., Wei, J., Schuurmans, D., Le, Q., Chi, E., Narang, S., Chowdhery, A., Zhou, D. (2022). Self-consistency improves chain of thought reasoning in language models. arXiv preprint arXiv:2203.11171

    2022 arXiv

  12. [20]

    Yao, S., Yu, D., Zhao, J., Shafran, I., Griffiths, T., Cao, Y., Narasimhan, K. (2024). Tree of thoughts: Deliberate problem solving with large language models. Advances in Neural Information Processing Systems, 36

    2024

  13. [21]

    J., Wang, Z., Wang, D

    Hao, S., Gu, Y., Ma, H., Hong, J. J., Wang, Z., Wang, D. Z., Hu, Z. (2023). Reasoning with language model is planning with world model. arXiv preprint arXiv:2305.14992

    2023 arXiv

  14. [22]

    Madaan, A., Tandon, N., Gupta, P., Hallinan, S., Gao, L., Wiegreffe, S., Alon, U., Dziri, N., Prabhumoye, S., Yang, Y., et al. (2024). Self-refine: Iterative refinement with self-feedback. Advances in Neural Information Processing Systems, 36

    2024

  15. [23]

    Zhou, A., Yan, K., Shlapentokh-Rothman, M., Wang, H., Wang, Y. X. (2023). Language agent tree search unifies reasoning acting and planning in language models. arXiv preprint arXiv:2310.04406

    2023 arXiv

  16. [24]

    Chen, X., Lin, M., Schärli, N., Zhou, D. (2023). Teaching large language models to self-debug. arXiv preprint arXiv:2304.05128

    2023 arXiv

  17. [25]

    Huang, D., Bu, Q., Cui, H. (2023). Codecot and beyond: Learning to program and test like a developer. arXiv preprint arXiv:2308.08784

    2023 arXiv

  18. [26]

    Zhang, D., Zhoubian, S., Hu, Z., Yue, Y., Dong, Y., Tang, J. (2024). Rest-mcts*: Llm self-training via process reward guided tree search. arXiv preprint arXiv:2406.03816

    2024 arXiv

  19. [27]

    Li, Q., Xia, W., Du, K., Dai, X., Tang, R., Wang, Y., Yu, Y., Zhang, W. (2024). RethinkMCTS: Refining Erroneous Thoughts in Monte Carlo Tree Search for Code Generation. arXiv preprint arXiv:2409.09584

    2024

  20. [28]

    L., Yang, F., Yang, M

    Qi, Z., Ma, M., Xu, J., Zhang, L. L., Yang, F., Yang, M. (2024). Mutual reasoning makes smaller llms stronger problem-solvers. arXiv preprint arXiv:2408.06195

    2024 arXiv

  21. [29]

    Wang, C., Deng, Y., Lyu, Z., Zeng, L., He, J., Yan, S., An, B. (2024). Q*: Improving multi-step reasoning for llms with deliberative planning. arXiv preprint arXiv:2406.14283

    2024 arXiv

  22. [30]

    Hui, W., Wang, Y., Tu, K., Jiang, C. (2024). RoT: Enhancing Large Language Models with Reflection on Search Trees. arXiv preprint arXiv:2404.05449

    2024 arXiv

  23. [31]

    Jiang, X., Dong, Y., Wang, L., Fang, Z., Shang, Q., Li, G., Jin, Z., Jiao, W. (2024). Self-planning code generation with large language models. ACM Transactions on Software Engineering and Methodology, 33(7), 1--30

    2024

  24. [32]

    Wang, E., Cassano, F., Wu, C., Bai, Y., Song, W., Nath, V., Han, Z., Hendryx, S., Yue, S., Zhang, H. (2024). Planning in natural language improves llm search for code generation. arXiv preprint arXiv:2409.03733

    2024 arXiv

  25. [33]

    Silver, D., Hubert, T., Schrittwieser, J., Antonoglou, I., Lai, M., Guez, A., Lanctot, M., Sifre, L., Kumaran, D., Graepel, T., et al. (2017). Mastering chess and shogi by self-play with a general reinforcement learning algorithm. arXiv preprint arXiv:1712.01815

    2017 arXiv

  26. [34]

    J., Guez, A., Sifre, L., Van Den Driessche, G., Schrittwieser, J., Antonoglou, I., Panneershelvam, V., Lanctot, M., et al

    Silver, D., Huang, A., Maddison, C. J., Guez, A., Sifre, L., Van Den Driessche, G., Schrittwieser, J., Antonoglou, I., Panneershelvam, V., Lanctot, M., et al. (2016). Mastering the game of Go with deep neural networks and tree search. Nature, 529(7587), 484--489

    2016

  27. [35]

    H., Gu, A., Li, W.-D., Yan, F., Zhang, T., Wang, S., Solar-Lezama, A., Sen, K., Stoica, I

    Naman Jain, K. H., Gu, A., Li, W.-D., Yan, F., Zhang, T., Wang, S., Solar-Lezama, A., Sen, K., Stoica, I. (2024). Livecodebench: Holistic and contamination free evaluation of large language models for code. arXiv preprint arXiv:2403.07974

    2024 arXiv

  28. [36]

    Shinn, N., Cassano, F., Labash, B., Gopinath, A., Narasimhan, K., Yao, S. (2023). Reflexion: Language agents with verbal reinforcement learning. arXiv preprint cs.AI/2303.11366

    2023 arXiv

Pith tools

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