Pith. sign in

REVIEW 4 major objections 5 minor 51 references

ToolACE-DEV: Self-Improving Tool Learning via Decomposition and EVolution

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

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

Pith's one-line read Self-evolution lets an 8B model beat larger rivals at tool calling.

desk verdict A solid, well-ablated empirical framework whose headline claim about self-evolution needs an external check on the self-generated labels before I'd take it at face value. read the letter →

arxiv 2505.07512 v1 pith:3UDV2YC7 submitted 2025-05-12 cs.CL cs.AI

Xu Huang , Weiwen Liu , Xingshan Zeng , Yuefeng Huang , Xinlong Hao , Yuxian Wang , Yirong Zeng , Chuhan Wu
show 3 more authors
Yasheng Wang Ruiming Tang Defu Lian
This is my paper · ORCID
classification cs.CLcs.AI
keywords toollearningself-evolutioninvocationfunctioncallingdatasynthesislightweightlanguagemodelsmajorityvotinggeneration
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

ToolACE-DEV asks whether a lightweight language model can improve its own tool-calling ability without a stronger teacher. The paper's answer is yes, provided the task is first decomposed: the model learns to reconstruct tool documentation, to generate query-relevant candidate tools, and to invoke them. After that preparation, the model writes its own new training examples, generating tools for fresh queries, sampling five invocations, and keeping the majority vote, and is fine-tuned on them. On the BFCL function-calling leaderboard, an 8B model trained this way reaches 82.44 overall, above several larger and closed-source models and on par with a much larger mixture-of-experts model. The central claim is that this self-evolution loop contributes real gains on top of the supervised stages, matching the effect of synthesizing data with an advanced model.

What carries the argument

The load-bearing mechanism is the decomposition of tool learning into two complementary training objectives plus a preparation task, followed by a self-consistency-based evolution loop. The preparation task, tool documentation adaption, trains the model to reconstruct a full tool definition from a one-line description, teaching the syntax of tool schemas. The two decomposed objectives are query-aware tool generation, turning a query into a set of candidate tools, and tool invocation, picking tools and filling arguments. In each evolution round the model generates candidate tools with sampling, draws five invocations, applies majority voting to choose the pseudo-ground-truth call, rejects only format errors with a rule checker, and updates itself with both objectives on the new triplets. The loop is what allows the model to expand its own tool set instead of relying on a fixed pool.

What would settle it

On a held-out set of several hundred queries with hand-verified correct invocations, run one evolution round and measure the accuracy of the majority-voted calls that become training data; if that accuracy is low or no better than the model's raw accuracy, the loop is training on its own noise. A sharper test compares the same base model fine-tuned on self-generated triplets versus an equal number of verified human or advanced-model triplets: the paper's claim predicts the self-generated set is not noticeably worse.

Watch

Extended reading notes

Core claim

The paper claims that tool learning for lightweight LLMs does not need to be a one-way distillation from advanced models. It decomposes the usual single objective into three teachable pieces: adapting to tool documentation, generating candidate tools from a query, and invoking those tools. Once an 8B model has these pieces, it can run a self-evolution loop: for each new query it invents its own tools, samples five possible invocations, takes the majority vote as ground truth, filters only format-level errors with a rule checker, and fine-tunes on the resulting triplets. The reported result is an 82.44 overall score on BFCL, exceeding Llama-3-70B-Instruct and several larger or closed models and matching xLAM-8x22B-r, with gains that persist across Llama, Qwen, and Mistral backbones. The paper states its conclusion as: self-evolution is as effective as data synthesis with advanced models.

Load-bearing premise

The loop trusts the model's own majority-voted invocations as correct training labels, and the rule checker only removes format errors, so if the majority is often semantically wrong for some class of queries, fine-tuning on those triplets amplifies the error.

Editorial extensions

If this is right

  • A 7-8B model can improve its function-calling accuracy without access to costly advanced models, cutting expense and sidestepping privacy restrictions that prohibit sending user queries to an external service.
  • Because the model invents candidate tools for fresh queries, it is not limited to a fixed tool pool, which targets zero-shot generalization to unseen scenarios.
  • Gains are larger on the harder, user-contributed live subset of BFCL than on the synthetic non-live subset, suggesting the self-generated training data is not trivially easy.
  • Self-evolution gains diminish with each round, and smaller models such as 1.5B and 3B stop improving or start to fluctuate, indicating a scale threshold for the benefit.
  • The same decomposition improves different model families, Llama, Qwen, and Mistral, so the mechanism is not tied to one base model.

Reading between the lines

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

  • The paper never checks whether majority-voted invocations are semantically correct; verifying them against a small set of human-annotated queries would separate genuine self-evolution from self-distillation.
  • The 10,000 queries per evolution round are not described as coming from a distribution different from BFCL, so a clean test would use held-out-domain queries to see whether the gains transfer rather than reflect benchmark-like fitting.
  • The success of majority voting suggests the model's errors are mostly unsystematic; where errors are systematic, such as a recurring argument-filling mistake, the loop would amplify them, and adding a verifier for a subset of generated calls could make the loop safer.
  • If the loop holds beyond function calling, it provides a recipe for self-improvement in any structured output task with a checkable schema, such as SQL generation or API orchestration.
Share X Bluesky LinkedIn Reddit HN

Signed reviews

No signed human review yet.

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 ToolACE-DEV, a three-stage framework for tool learning in lightweight LLMs: (i) tool documentation adaption, (ii) query-aware tool generation plus invocation, and (iii) a self-evolution loop in which the model generates candidate tools, samples multiple invocations, and fine-tunes on majority-voted pseudo-labels. Experiments on Llama-3.1-8B, Qwen2.5 variants (1.5B, 3B, 7B), and Mistral-7B report consistent improvements on BFCL, API-Bank, and T-Eval, with the 8B model reaching an Overall score of 82.44 on BFCL. The authors claim that self-evolution is as effective as data synthesis with advanced models, and that task decomposition is key to the gains.

Significance. If the central claim is validated, the framework offers a practical route to reducing dependence on costly advanced-model data synthesis for tool calling, and the decomposition into documentation adaption, tool generation, and invocation is a plausible and potentially transferable design. The paper deserves credit for the breadth of the empirical study: ablations across model families and scales, three benchmarks, and clear per-stage analysis. The self-generated training signal, however, is the load-bearing component, and the manuscript does not yet establish that this signal is semantically correct or that the benchmark comparisons are apples-to-apples. These gaps are fixable in principle, making the work a strong candidate for major revision rather than rejection.

major comments (4)
  1. [Section 3.4, Eq. (5)] The self-evolution loop selects the training target for each query by majority voting over five invocations sampled from the model itself, with only a rule checker for format/type errors. The paper never reports the oracle accuracy of these voted labels, nor does it compare them against any external ground truth. If the model has a systematic bias for a class of queries, majority voting can amplify rather than correct that bias, and iterated fine-tuning on such pseudo-labels can improve fluency on the model's own output distribution without improving genuine tool-calling ability. Since the central claim is that self-evolution matches advanced-model data synthesis, the authors should validate the pseudo-labels on a held-out set (e.g., by measuring agreement with human or LLM-as-judge correctness, or by executing calls in a sandbox) and report the accuracy of the voted invocations per evolution round.
  2. [Section 4.1] The source of the 10,000 incoming queries per self-evolution round is not specified. If these queries overlap with the BFCL test distribution, or even resemble it in domain and style, the observed BFCL gains could partly reflect distribution fitting rather than improved tool-calling ability. The paper should state where the queries come from, how they were sampled, and what decontamination checks were performed against BFCL, API-Bank, and T-Eval. At minimum, the authors should demonstrate that queries from different rounds do not duplicate the benchmark test cases.
  3. [Table 1 and Section 4.1] The comparison with the BFCL leaderboard is problematic. The paper states that evaluation focused exclusively on single-turn AST data, yet the baseline scores in Table 1 are taken from the official leaderboard, whose Overall score aggregates additional categories (e.g., multi-turn and executable-style cases). A score computed on a subset with different composition is not directly comparable to the published Overall score of other models. The authors must either recompute all baseline scores on the same single-turn AST subset used for ToolACE-DEV, or evaluate ToolACE-DEV on the full leaderboard protocol. In addition, the sentence 'the best results (may not be at the third round) are adopted in Table 1' implies test-set-based model selection across evolution rounds; if the round was chosen by looking at BFCL scores, the reported numbers are optimistically biased and should be replaced by a prespecified selection rule (e.g., a validation split) or by reporting all rounds.
  4. [Section 4.2 and Table 3] The claim that 'the self-evolution process is as effective as data synthesis with advanced models' is not directly supported by the presented experiments. The comparison is between ToolACE-DEV (which includes the two supervised stages plus self-evolution) and ToolACE-8B, which was trained on a different dataset size and composition. The ablation in Table 3 shows that Invo.+Gen. w. Adaption already reaches 81.67 Overall, while the full ToolACE-DEV reaches 82.44, an increment of 0.77 points. To substantiate the equivalence claim, the authors need a controlled comparison: for example, replacing self-evolution with an equal number of additional GPT-4-synthesized samples, or training a variant that uses only GPT-4-synthesized data at the same total scale as the self-evolved data. Without such a comparison, the headline claim overreaches.
minor comments (5)
  1. [Abstract and Section 1] The phrase 'first self-evolutionary framework designed to enhance LLMs' tool-invocation capabilities' is an overclaim given prior self-training work for tool use (e.g., Toolformer); consider softening to 'a self-evolutionary framework' and discussing the distinction more carefully.
  2. [Section 4.5 and Figure 3(b)] The text refers to a '1.8B model,' but the corresponding figure and experiments use Qwen2.5-1.5B. Please correct the model size or clarify the configuration.
  3. [Section 4.3] The phrase 'leading to a hypothesize' should be 'leading to a hypothesis.'
  4. [References and prompts] There are minor typos in the references and appendices, such as 'V olume' in the T-Eval citation and duplicated system prompts in Figures 6 and 7; a careful proofread is recommended.
  5. [Section 3.2] The term 'adaption' is used throughout; 'adaptation' is the more standard spelling in English. Consistency would improve readability.

Circularity Check

0 steps flagged · score 0.0 of 10

No significant circularity: the self-evolution loop is validated on external benchmarks, and the ToolACE data citation is provenance, not a load-bearing self-citation.

full rationale

The paper's derivation chain is not circular by construction. The self-evolution loop (Eq. 5) uses majority voting over the model's own samples as a pseudo-label, and Eq. 6 fine-tunes on those triplets; this is an explicit self-training design, not a hidden equivalence between input and output. The central claim that self-evolution is as effective as advanced-model data synthesis is supported by external evaluations on BFCL (Table 1), API-Bank, and T-Eval (Table 2), and by ablations (Table 3, Figure 2) that compare against the raw model and ToolACE-8B. The BFCL scores are not derived from the self-generated labels; they are independently computed against held-out test cases. The cited prior work ToolACE (Liu et al., 2024a) is used as a data source (26,522 tool documents and the 20,000 initial GPT-4-synthesized samples) and as a baseline model; this is data provenance and comparison, not an unverified theorem imported to force the conclusion. Potential threats, such as the lack of semantic verification of majority-voted invocations and the unspecified distribution of the 10,000 queries per round, are genuine correctness and validity concerns, but they do not make any claimed result equivalent to its input by definition. The paper therefore merits a circularity score of 0.

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

The framework's scientific content is a training recipe; it introduces no new physical entities. The central load-bearing assumptions are about the validity of self-generated labels and the comparability of benchmark numbers with the leaderboard.

free parameters (6)
  • max_self_evolution_rounds = 3
    Maximum iterations of self-training; Table 1 adopts the best round across rounds, which can inflate reported performance.
  • voting_samples_k = 5
    Number of self-consistency samples for majority voting in Eq. 5; larger k likely improves label quality at higher compute cost.
  • generation_temperature = 1.0
    Temperature for candidate tool generation to increase diversity (Appendix A.3); affects the distribution of self-generated training data.
  • lora_rank_alpha = rank=16, alpha=32
    LoRA hyperparameters for parameter-efficient fine-tuning; standard values, not tuned per task.
  • learning_rate = 1e-4
    Cosine learning rate with 0.1 warmup; standard choice for fine-tuning.
  • labeled_data_size = 20,000
    Number of GPT-4 synthesized invocation samples used in stage 2; the claim of reduced reliance on advanced models still requires this external data.
assumptions (6)
  • domain assumption Majority voting over 5 self-consistency samples of the target model yields sufficiently correct tool invocations to serve as training labels.
    Used in Eq. 5 to define the ground truth A-tilde; no external oracle validates semantic correctness.
  • domain assumption The rule checker can reliably distinguish well-formed, non-hallucinated tool calls from malformed ones.
    Section 3.4 uses the checker to filter candidate tools and invocations; the paper does not specify the checker's rules or its false-negative rate.
  • domain assumption BFCL, API-Bank, and T-Eval are valid, transferable measures of tool invocation capability.
    Section 4.1 uses these benchmarks as the sole evaluation; no analysis of benchmark saturation or domain gap is provided.
  • domain assumption The ToolACE dataset (26,522 tools) is representative of tool documentation across real-world APIs.
    Section 4.1 draws adaption data from this dataset, which was curated in the authors' prior work.
  • domain assumption Self-generated training data does not cause distribution collapse over 3 fine-tuning rounds.
    Section 3.4 assumes iterative self-training improves rather than degenerates; Figure 2 shows gains but provides no divergence analysis.
  • ad hoc to paper Using only single-turn AST subsets of BFCL permits direct comparison with leaderboard Overall scores.
    Footnote 2 in Section 4.1 restricts evaluation to single-turn AST, while Table 1 compares against leaderboard Overall that includes additional categories.

how reviews work

0 comments
Cite this review

Pith. "Pith review of ToolACE-DEV: Self-Improving Tool Learning via Decomposition and EVolution." pith.science (2026). https://pith.science/paper/3UDV2YC7

@misc{pith2026250507512,
  author       = {Pith},
  title        = {Pith review of: ToolACE-DEV: Self-Improving Tool Learning via Decomposition and EVolution},
  year         = {2026},
  howpublished = {\url{https://pith.science/paper/3UDV2YC7}},
  note         = {Machine review of arXiv:2505.07512}
}
read the original abstract

The tool-using capability of large language models (LLMs) enables them to access up-to-date external information and handle complex tasks. Current approaches to enhancing this capability primarily rely on distilling advanced models by data synthesis. However, this method incurs significant costs associated with advanced model usage and often results in data compatibility issues, led by the high discrepancy in the knowledge scope between the advanced model and the target model. To address these challenges, we propose ToolACE-DEV, a self-improving framework for tool learning. First, we decompose the tool-learning objective into sub-tasks that enhance basic tool-making and tool-using abilities. Then, we introduce a self-evolving paradigm that allows lightweight models to self-improve, reducing reliance on advanced LLMs. Extensive experiments validate the effectiveness of our approach across models of varying scales and architectures.

Figures

Figures reproduced from arXiv: 2505.07512 by the authors.

Figure 1
Figure 1. Overall framework of the self-evolving paradigm. (a) Tool documentation adaption, aiming to enhance [PITH_FULL_IMAGE:figures/full_fig_p003_1.png] view at source ↗
Figure 2
Figure 2. Relative Improvements of Self-Evolution. The [PITH_FULL_IMAGE:figures/full_fig_p006_2.png] view at source ↗
Figure 3
Figure 3. Ablation study of different training objectives [PITH_FULL_IMAGE:figures/full_fig_p007_3.png] view at source ↗
Figures from the paper (4 more)
Figure 4
Figure 4. Figure 4: Effects of self-evolution on various models. [PITH_FULL_IMAGE:figures/full_fig_p008_4.png]
Figure 5
Figure 5. Figure 5: Illustration of the tool invocation task. The blue part represents the expected output. [PITH_FULL_IMAGE:figures/full_fig_p013_5.png]
Figure 6
Figure 6. Figure 6: Illustration of the tool documentation pre-SFT task. The blue part represents the expected output. [PITH_FULL_IMAGE:figures/full_fig_p014_6.png]
Figure 7
Figure 7. Figure 7: Illustration of the query-aware tool generation task. The blue part represents the expected output. [PITH_FULL_IMAGE:figures/full_fig_p015_7.png]

Discussion (0). Continue with ORCID to comment.

Reference graph

Works this paper leans on

51 extracted references · 3 canonical work pages

  1. [1]

    online" 'onlinestring :=

    ENTRY address archivePrefix author booktitle chapter edition editor eid eprint eprinttype howpublished institution journal key month note number organization pages publisher school series title type volume year doi pubmed url lastchecked label extra.label sort.label short.list INTEGERS output.state before.all mid.sentence after.sentence after.block STRING...

  2. [2]

    write newline

    " write newline "" before.all 'output.state := FUNCTION n.dashify 't := "" t empty not t #1 #1 substring "-" = t #1 #2 substring "--" = not "--" * t #2 global.max substring 't := t #1 #1 substring "-" = "-" * t #2 global.max substring 't := while if t #1 #1 substring * t #2 global.max substring 't := if while FUNCTION word.in bbl.in capitalize " " * FUNCT...

  3. [3]

    Ibrahim Abdelaziz, Kinjal Basu, Mayank Agarwal, Sadhana Kumaravel, Matthew Stallone, Rameswar Panda, Yara Rizk, GP Bhargav, Maxwell Crouse, Chulaka Gunasekara, et al. 2024. Granite-function calling model: Introducing function calling abilities via multi-task learning of granular tasks. arXiv preprint arXiv:2407.00121

    arXiv 2024

  4. [4]

    AI@Meta. 2024. https://github.com/meta-llama/llama3/blob/main/MODEL_CARD.md Llama 3 model card

    2024

  5. [5]

    Weixin Chen, Dawn Song, and Bo Li. 2024 a . Grath: gradual self-truthifying for large language models. arXiv preprint arXiv:2401.12292

    arXiv 2024

  6. [6]

    Xinyun Chen, Maxwell Lin, Nathanael Sch \"a rli, and Denny Zhou. 2024 b . https://openreview.net/forum?id=KuPixIqPiq Teaching large language models to self-debug . In The Twelfth International Conference on Learning Representations

    work page 2024

  7. [7]

    Zehui Chen, Weihua Du, Wenwei Zhang, Kuikun Liu, Jiangning Liu, Miao Zheng, Jingming Zhuo, Songyang Zhang, Dahua Lin, Kai Chen, and Feng Zhao. 2024 c . https://doi.org/10.18653/v1/2024.acl-long.515 T -eval: Evaluating the tool utilization capability of large language models step by step . In Proceedings of the 62nd Annual Meeting of the Association for Co...

    doi:10.18653/v1/2024.acl-long.515 2024

  8. [8]

    Zixiang Chen, Yihe Deng, Huizhuo Yuan, Kaixuan Ji, and Quanquan Gu. 2024 d . Self-play fine-tuning converts weak language models to strong language models. arXiv preprint arXiv:2401.01335

    arXiv 2024

Show all 51 references
  1. [9]

    Karl Cobbe, Vineet Kosaraju, Mohammad Bavarian, Mark Chen, Heewoo Jun, Lukasz Kaiser, Matthias Plappert, Jerry Tworek, Jacob Hilton, Reiichiro Nakano, et al. 2021. Training verifiers to solve math word problems. arXiv preprint arXiv:2110.14168

    2021 arXiv

  2. [10]

    Wanyun Cui and Qianle Wang. 2023. Ada-instruct: Adapting instruction generators for complex reasoning. arXiv preprint arXiv:2310.04484

    2023 arXiv

  3. [11]

    Caglar Gulcehre, Tom Le Paine, Srivatsan Srinivasan, Ksenia Konyushkova, Lotte Weerts, Abhishek Sharma, Aditya Siddhant, Alex Ahern, Miaosen Wang, Chenjie Gu, et al. 2023. Reinforced self-training (rest) for language modeling. arXiv preprint arXiv:2308.08998

    2023 arXiv

  4. [12]

    Valentin Hartmann, Anshuman Suri, Vincent Bindschaedler, David Evans, Shruti Tople, and Robert West. 2023. Sok: Memorization in general-purpose large language models. arXiv preprint arXiv:2310.18362

    2023 arXiv

  5. [13]

    Joy He-Yueya, Gabriel Poesia, Rose E Wang, and Noah D Goodman. 2023. Solving math word problems by combining language models with symbolic solvers. arXiv preprint arXiv:2304.09102

    2023 arXiv

  6. [14]

    Cheng-Yu Hsieh, Si-An Chen, Chun-Liang Li, Yasuhisa Fujii, Alexander Ratner, Chen-Yu Lee, Ranjay Krishna, and Tomas Pfister. 2023. https://arxiv.org/abs/2308.00675 Tool documentation enables zero-shot tool-usage with large language models . Preprint, arXiv:2308.00675

    2023 arXiv

  7. [15]

    Edward J Hu, yelong shen, Phillip Wallis, Zeyuan Allen-Zhu, Yuanzhi Li, Shean Wang, Lu Wang, and Weizhu Chen. 2022. https://openreview.net/forum?id=nZeVKeeFYf9 Lo RA : Low-rank adaptation of large language models . In International Conference on Learning Representations

    2022

  8. [16]

    Jiaxin Huang, Shixiang Gu, Le Hou, Yuexin Wu, Xuezhi Wang, Hongkun Yu, and Jiawei Han. 2023. https://doi.org/10.18653/v1/2023.emnlp-main.67 Large language models can self-improve . In Proceedings of the 2023 Conference on Empirical Methods in Natural Language Processing, pages...

    2023 doi

  9. [17]

    Shijue Huang, Wanjun Zhong, Jianqiao Lu, Qi Zhu, Jiahui Gao, Weiwen Liu, Yutai Hou, Xingshan Zeng, Yasheng Wang, Lifeng Shang, et al. 2024. Planning, creation, usage: Benchmarking llms for comprehensive tool utilization in real-world complex scenarios. arXiv preprint arXiv:2401.17167

    2024 arXiv

  10. [18]

    Shuyang Jiang, Yuhao Wang, and Yu Wang. 2023. Selfevolve: A code evolution framework via large language models. arXiv preprint arXiv:2306.02907

    2023 arXiv

  11. [19]

    Katie Kang, Eric Wallace, Claire Tomlin, Aviral Kumar, and Sergey Levine. 2024. Unfamiliar finetuning examples control how language models hallucinate. arXiv preprint arXiv:2403.05612

    2024 arXiv

  12. [20]

    Gonzalez, Hao Zhang, and Ion Stoica

    Woosuk Kwon, Zhuohan Li, Siyuan Zhuang, Ying Sheng, Lianmin Zheng, Cody Hao Yu, Joseph E. Gonzalez, Hao Zhang, and Ion Stoica. 2023. Efficient memory management for large language model serving with pagedattention. In Proceedings of the ACM SIGOPS 29th Symposium on Operating S...

    2023

  13. [21]

    Minghao Li, Yingxiu Zhao, Bowen Yu, Feifan Song, Hangyu Li, Haiyang Yu, Zhoujun Li, Fei Huang, and Yongbin Li. 2023. Api-bank: A comprehensive benchmark for tool-augmented llms. arXiv preprint arXiv:2304.08244

    2023 arXiv

  14. [22]

    Qiqiang Lin, Muning Wen, Qiuying Peng, Guanyu Nie, Junwei Liao, Jun Wang, Xiaoyun Mo, Jiamu Zhou, Cheng Cheng, Yin Zhao, et al. 2024. Hammer: Robust function-calling for on-device language models via function masking. arXiv preprint arXiv:2410.04587

    2024

  15. [23]

    Weiwen Liu, Xu Huang, Xingshan Zeng, Xinlong Hao, Shuai Yu, Dexun Li, Shuai Wang, Weinan Gan, Zhengying Liu, Yuanqing Yu, Zezhong Wang, Yuxian Wang, Wu Ning, Yutai Hou, Bin Wang, Chuhan Wu, Xinzhi Wang, Yong Liu, Yasheng Wang, Duyu Tang, Dandan Tu, Lifeng Shang, Xin Jiang, Rui...

    2024 arXiv

  16. [24]

    Zuxin Liu, Thai Hoang, Jianguo Zhang, Ming Zhu, Tian Lan, Shirley Kokane, Juntao Tan, Weiran Yao, Zhiwei Liu, Yihao Feng, et al. 2024 b . Apigen: Automated pipeline for generating verifiable and diverse function-calling datasets. arXiv preprint arXiv:2406.18518

    2024 arXiv

  17. [25]

    Grégoire Mialon, Roberto Dessì, Maria Lomeli, Christoforos Nalmpantis, Ram Pasunuru, Roberta Raileanu, Baptiste Rozière, Timo Schick, Jane Dwivedi-Yu, Asli Celikyilmaz, Edouard Grave, Yann LeCun, and Thomas Scialom. 2023. https://arxiv.org/abs/2302.07842 Augmented language mod...

    2023 arXiv

  18. [26]

    Mistral-AI. 2024. https://huggingface.co/mistralai/Mistral-7B-Instruct-v0.3 Mistral-7b-instruct-v0.3

    2024

  19. [27]

    Reiichiro Nakano, Jacob Hilton, Suchir Balaji, Jeff Wu, Long Ouyang, Christina Kim, Christopher Hesse, Shantanu Jain, Vineet Kosaraju, William Saunders, et al. 2021. Webgpt: Browser-assisted question-answering with human feedback. arXiv preprint arXiv:2112.09332

    2021 arXiv

  20. [28]

    Shishir G Patil, Tianjun Zhang, Xin Wang, and Joseph E Gonzalez. 2023. Gorilla: Large language model connected with massive apis. arXiv preprint arXiv:2305.15334

    2023 arXiv

  21. [29]

    Yujia Qin, Shihao Liang, Yining Ye, Kunlun Zhu, Lan Yan, Yaxi Lu, Yankai Lin, Xin Cong, Xiangru Tang, Bill Qian, et al. 2023. Toolllm: Facilitating large language models to master 16000+ real-world apis. arXiv preprint arXiv:2307.16789

    2023 arXiv

  22. [30]

    Qwen-Team. 2024. https://qwenlm.github.io/blog/qwen2.5/ Qwen2.5: A party of foundation models

    2024

  23. [31]

    Rafael Rafailov, Archit Sharma, Eric Mitchell, Christopher D Manning, Stefano Ermon, and Chelsea Finn. 2024. Direct preference optimization: Your language model is secretly a reward model. Advances in Neural Information Processing Systems, 36

    2024

  24. [32]

    Jingqing Ruan, Yihong Chen, Bin Zhang, Zhiwei Xu, Tianpeng Bao, Guoqing Du, Shiwei Shi, Hangyu Mao, Ziyue Li, Xingyu Zeng, and Rui Zhao. 2023. https://arxiv.org/abs/2308.03427 Tptu: Large language model-based ai agents for task planning and tool usage . Preprint, arXiv:2308.03427

    2023

  25. [33]

    Timo Schick, Jane Dwivedi-Yu, Roberto Dessì, Roberta Raileanu, Maria Lomeli, Luke Zettlemoyer, Nicola Cancedda, and Thomas Scialom. 2023. https://arxiv.org/abs/2302.04761 Toolformer: Language models can teach themselves to use tools . Preprint, arXiv:2302.04761

    2023 arXiv

  26. [34]

    Amrith Setlur, Saurabh Garg, Xinyang Geng, Naman Garg, Virginia Smith, and Aviral Kumar. 2024. Rl on incorrect synthetic data scales the efficiency of llm math reasoning by eight-fold. arXiv preprint arXiv:2406.14532

    2024 arXiv

  27. [35]

    David Silver, Aja Huang, Chris J Maddison, Arthur Guez, Laurent Sifre, George Van Den Driessche, Julian Schrittwieser, Ioannis Antonoglou, Veda Panneershelvam, Marc Lanctot, et al. 2016. Mastering the game of go with deep neural networks and tree search. nature, 529(7587):484--489

    2016

  28. [36]

    David Silver, Thomas Hubert, Julian Schrittwieser, Ioannis Antonoglou, Matthew Lai, Arthur Guez, Marc Lanctot, Laurent Sifre, Dharshan Kumaran, Thore Graepel, et al. 2017. Mastering chess and shogi by self-play with a general reinforcement learning algorithm. arXiv preprint ar...

    2017 arXiv

  29. [37]

    Avi Singh, John D Co-Reyes, Rishabh Agarwal, Ankesh Anand, Piyush Patil, Xavier Garcia, Peter J Liu, James Harrison, Jaehoon Lee, Kelvin Xu, et al. 2023. Beyond human data: Scaling self-training for problem-solving with language models. arXiv preprint arXiv:2312.06585

    2023 arXiv

  30. [38]

    Karan Singhal, Tao Tu, Juraj Gottweis, Rory Sayres, Ellery Wulczyn, Mohamed Amin, Le Hou, Kevin Clark, Stephen R Pfohl, Heather Cole-Lewis, et al. 2025. Toward expert-level medical question answering with large language models. Nature Medicine, pages 1--8

    2025

  31. [39]

    Qiaoyu Tang, Ziliang Deng, Hongyu Lin, Xianpei Han, Qiao Liang, Boxi Cao, and Le Sun. 2023. Toolalpaca: Generalized tool learning for language models with 3000 simulated cases. arXiv preprint arXiv:2306.05301

    2023 arXiv

  32. [40]

    Zhengwei Tao, Ting-En Lin, Xiancai Chen, Hangyu Li, Yuchuan Wu, Yongbin Li, Zhi Jin, Fei Huang, Dacheng Tao, and Jingren Zhou. 2024. A survey on self-evolution of large language models. arXiv preprint arXiv:2404.14387

    2024 arXiv

  33. [41]

    Kushal Tirumala, Aram Markosyan, Luke Zettlemoyer, and Armen Aghajanyan. 2022. Memorization without overfitting: Analyzing the training dynamics of large language models. Advances in Neural Information Processing Systems, 35:38274--38290

    2022

  34. [42]

    Chi, Sharan Narang, Aakanksha Chowdhery, and Denny Zhou

    Xuezhi Wang, Jason Wei, Dale Schuurmans, Quoc V Le, Ed H. Chi, Sharan Narang, Aakanksha Chowdhery, and Denny Zhou. 2023. https://openreview.net/forum?id=1PL1NIMMrw Self-consistency improves chain of thought reasoning in language models . In The Eleventh International Conferenc...

    2023

  35. [43]

    Yizhong Wang, Yeganeh Kordi, Swaroop Mishra, Alisa Liu, Noah A Smith, Daniel Khashabi, and Hannaneh Hajishirzi. 2022. Self-instruct: Aligning language models with self-generated instructions. arXiv preprint arXiv:2212.10560

    2022 arXiv

  36. [44]

    Shijie Wu, Ozan Irsoy, Steven Lu, Vadim Dabravolski, Mark Dredze, Sebastian Gehrmann, Prabhanjan Kambadur, David Rosenberg, and Gideon Mann. 2023. Bloomberggpt: A large language model for finance. arXiv preprint arXiv:2303.17564

    2023 arXiv

  37. [45]

    Can Xu, Qingfeng Sun, Kai Zheng, Xiubo Geng, Pu Zhao, Jiazhan Feng, Chongyang Tao, and Daxin Jiang. 2023. Wizardlm: Empowering large language models to follow complex instructions. arXiv preprint arXiv:2304.12244

    2023 arXiv

  38. [46]

    Patil, Ion Stoica, and Joseph E

    Fanjia Yan, Huanzhi Mao, Charlie Cheng-Jie Ji, Tianjun Zhang, Shishir G. Patil, Ion Stoica, and Joseph E. Gonzalez. 2024. Berkeley function calling leaderboard. https://gorilla.cs.berkeley.edu/blogs/8_berkeley_function_calling_leaderboard.html

    2024

  39. [47]

    Shunyu Yao, Jeffrey Zhao, Dian Yu, Nan Du, Izhak Shafran, Karthik R Narasimhan, and Yuan Cao. 2023. React: Synergizing reasoning and acting in language models. In The Eleventh International Conference on Learning Representations

    2023

  40. [48]

    Weizhe Yuan, Richard Yuanzhe Pang, Kyunghyun Cho, Sainbayar Sukhbaatar, Jing Xu, and Jason Weston. 2024. Self-rewarding language models. arXiv preprint arXiv:2401.10020

    2024 arXiv

  41. [49]

    Eric Zelikman, YH Wu, Jesse Mu, and Noah D Goodman. 2024. Star: Self-taught reasoner bootstrapping reasoning with reasoning. In Proc. the 36th International Conference on Neural Information Processing Systems, volume 1126

    2024

  42. [50]

    Jianguo Zhang, Tian Lan, Ming Zhu, Zuxin Liu, Thai Hoang, Shirley Kokane, Weiran Yao, Juntao Tan, Akshara Prabhakar, Haolin Chen, Zhiwei Liu, Yihao Feng, Tulika Awalgaonkar, Rithesh Murthy, Eric Hu, Zeyuan Chen, Ran Xu, Juan Carlos Niebles, Shelby Heinecke, Huan Wang, Silvio S...

    2024 arXiv

  43. [51]

    Wenqi Zhang, Yongliang Shen, Linjuan Wu, Qiuying Peng, Jun Wang, Yueting Zhuang, and Weiming Lu. 2024 b . https://doi.org/10.18653/v1/2024.acl-long.197 Self-contrast: Better reflection through inconsistent solving perspectives . In Proceedings of the 62nd Annual Meeting of the...

    2024 doi

Pith tools

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