Pith. sign in

REVIEW 3 major objections 3 minor 1 cited by

TL-Training: A Task-Feature-Based Framework for Training Large Language Models in Tool Use

T0 review · 3 major / 3 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 The paper claims that a three-part task-feature training recipe lets a 7B model match or surpass leading open- and closed-source LLMs on tool-use benchmarks using only 1,217 training examples.

desk verdict Data-efficient tool-use training framework with strong single-turn results; the multi-turn ToolEyes claim needs a train/test overlap check and the appendix proofs are tautological. read the letter →

arxiv 2412.15495 v2 pith:EY3PDNJB submitted 2024-12-20 cs.CL cs.AI

Junjie Ye , Yilong Wu , Sixian Li , Yuming Yang , Zhiheng Xi , Tao Gui , Qi Zhang , Xuanjing Huang
show 4 more authors
Peng Wang Zhongchao Shi Jianping Fan Zhengyin Du
This is my paper · ORCID
classification cs.CLcs.AI
keywords toollearninglargelanguagemodelssupervisedfine-tuningreinforcementproximalpolicyoptimizationtokenweightingdataefficiencyfunctioncalling
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

TL-Training is a three-part recipe for teaching a large language model to call external tools, and the paper claims that the recipe lets a 7-billion-parameter model trained on only 1,217 interaction traces match or beat much larger open- and closed-source models on four tool-use benchmarks. The first part inspects tool feedback to detect erroneous tool calls inside training trajectories and blocks those steps from gradient updates. The second reweights the training loss so that tokens that are most diagnostic for choosing the right tool, such as the first token of a tool name, get larger gradient contribution. The third defines a reward function keyed to a small taxonomy of tool-call errors and tunes the model with PPO. If the claim holds, data-efficient, task-aware training can substitute for massive tool-use datasets.

What carries the argument

The load-bearing mechanism is a training pipeline with three training modifications. The first, adverse-effects mitigation (MAE), parses tool feedback such as 'name x is not defined' or 'missing required positional argument' to detect erroneous steps and excludes them from the SFT loss, preventing the model from learning bad calls. The second, key-token prioritization (PKT), classifies tokens of each tool name into key and non-key sets (key tokens include the first token and any token whose prefix is shared with another tool) and multiplies their SFT loss weight by $w = \mathrm{CLIP}(|NK_i|/|K_i|, 1, w_{\max})$, so the model pays more gradient attention where tool names are easy to confuse. The third, the reward mechanism, maps a generated tool call to one of five categories—parse failure, tool hallucination, wrong tool, parameter issues, content filling—with rewards from $-2$ to $1$, and optimizes the model with PPO against a KL penalty that keeps it near the SFT model. Each component is ablated and each contributes; the full stack outperforms standard SFT on the four test sets.

What would settle it

Retrain TL-CodeLLaMA-2 on 1,217 trajectories built from a disjoint set of tools (not the ToolEyes suite) and run the same four test sets; if the ToolEyes multi-turn scores (DE 0.82, CE 4.84, VA 77.75) drop sharply while single-turn scores hold, the original multi-turn result was inflated by training-test overlap. Alternatively, compute the fraction of ToolEyes test queries whose tool names or API-call patterns appear in the training set; a non-negligible overlap would settle the concern.

Watch

Extended reading notes

Core claim

The paper's central discovery is that tool-use training is bottlenecked not by data quantity but by task-specific characteristics that standard SFT ignores, and that correcting for these characteristics unlocks state-of-the-art behavior from a small model. Analyzing existing tool-use LLMs, the authors find that (i) about 17% of the trajectories in an existing training set contain tool-calling errors, and training on them teaches the model to repeat those errors; (ii) wrong tool selections often differ from correct ones only in an early token, so the first tokens and shared-prefix tokens carry disproportionate importance; and (iii) tool-call errors collapse into a small set of categories visible in tool feedback. TL-Training operationalizes these insights: MAE masks erroneous interaction paths from back-propagation, PKT upweights key tokens by a clipped ratio of non-key to key tokens, and IRM assigns graded rewards for different error types during PPO. Trained on 1,217 GPT-4o-generated multi-turn trajectories over ToolEyes tools, the resulting 7B model, TL-CodeLLaMA-2, matches or surpasses GPT-4-class and specialized tool-use models on ToolAlpaca, RoTBench, BFCL-v3, and ToolEyes, while improving robustness to noisy tool descriptions and preserving general task performance.

Load-bearing premise

The multi-turn result on ToolEyes rests on the assumption that the 1,217 training trajectories constructed from ToolEyes tools do not overlap with the ToolEyes test queries; if the same tools or usage patterns appear in both, the reported gains partly reflect memorization rather than generalization, and the paper does not state the disjointness.

Editorial extensions

If this is right

  • A 7B model with 1,217 training trajectories can match or beat much larger and heavily trained models on single-turn tool selection, parameter identification, and content filling across ToolAlpaca, RoTBench, and BFCL-v3.
  • On multi-turn tool use, TL-CodeLLaMA-2 achieves a low total error rate on ToolEyes and the highest valid-answer rate among all compared open-source models, while remaining competitive with GPT-4-class closed models.
  • The model is more robust than a model specifically optimized for noisy tool environments, reaching or exceeding RoTLLaMA on RoTBench's noisy splits without targeted noise augmentation.
  • General knowledge and code/math capabilities are preserved (MMLU, GSM8K, HumanEval) after tool-use fine-tuning, with slight gains on math and code, so the method does not trade away general ability.
  • Each of the three components contributes to the final performance in ablations; masking erroneous trajectories alone cuts the multi-turn tool-call error rate by about one-third.

Reading between the lines

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

  • If the training-test overlap concern is resolved, the same three components should transfer to other structured-generation tasks such as SQL generation, API calls, and robotic control, where a small taxonomy of errors is available from environment feedback.
  • The key-token weighting rule is parameter-light and could be adapted to other domains by defining key tokens from confusion statistics rather than tool-name prefixes; this is a natural testable extension the paper does not pursue.
  • Because the reward function is hand-crafted from a fixed error taxonomy, a learned reward model could capture rare error types; the paper notes it does not train one, so this is an open extension.
  • The claim that compact task-aware data can substitute for large datasets suggests that dataset quality engineering may matter more than scale for tool use, and the paper's ablation structure gives a template for testing that hypothesis.
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

3 major / 3 minor

Summary. The paper proposes TL-Training, a three-component framework for tool-use fine-tuning of LLMs: masking erroneous interaction trajectories during SFT (MAE), adaptively up-weighting key tokens during SFT (PKT), and applying PPO with an error-category-based reward (IRM). The authors train CodeLLaMA-2-7B on 1,217 GPT-4o-generated trajectories and evaluate on ToolAlpaca, RoTBench, BFCL-v3, and ToolEyes, reporting that the resulting model matches or surpasses several open- and closed-source baselines, improves robustness on noisy tool environments, and preserves general task performance. The central claim is that a compact, task-feature-aware training set plus the proposed loss and reward design suffices to reach state-of-the-art tool-use performance with a 7B model.

Significance. If the results hold, the paper offers a practical and data-efficient alternative to large-scale SFT for tool use, with the notable strengths of a compact training set, public code and data, an explicit error taxonomy, and an ablation design covering each proposed component. The single-turn results on ToolAlpaca, RoTBench, and BFCL-v3 are more credible because those test sets use different task distributions from the training set. However, the multi-turn ToolEyes comparison, which is load-bearing for the claim of matching closed-source models on multi-turn tool use, is currently weakened by the lack of reported train/test disjointness and by small test sizes with single-run evaluations. The reward function is also constructed from the same error categories used in the evaluation metrics, so the multi-turn conclusions require additional evidence of generalization.

major comments (3)
  1. [§5.1, Appendix B, Table 4] The ToolEyes multi-turn result is not supported as a generalization result unless the training and test sets are known to be disjoint. Appendix B states that the 1,217 training trajectories are 'artificially create[d]' using ToolEyes as the tool foundation, while Table 2 lists the same ToolEyes benchmark (382 multi-turn cases) as the test set. The paper never reports a query-level or tool-level overlap check, deduplication, or any exclusion of ToolEyes test instances from the generated training data. If even a modest fraction of the 382 test queries appear in the training set, exactly or through similar tool-call sequences, the Table 4 numbers (DE 0.82, CE 4.84, VA 77.75) and the claim of matching GPT-4o on multi-turn tool use are inflated by memorization rather than reflecting genuine tool-use ability. Please provide an explicit overlap analysis between the 1,217 training trajectories and the 382 ToolEyes test cases, or evaluate the multi-turn claim on a held-out set built from different tools.
  2. [§4.3, §5.3] The reward function in Section 4.3 is built from the same error taxonomy that defines the evaluation metrics in Section 5.3: tool hallucination, parameter hallucination, missing or redundant parameters, and content filling issues. The PPO stage is therefore trained on a proxy that is closely aligned with the benchmark scoring rules, so the large gains from the IRM component in Table 5 (e.g., ToolAlpaca CF from 42.98 to 57.02 when IRM is added) may partly reflect fitting the model to the benchmark rather than improving general tool-use competence. This concern is especially relevant because the same trajectory set used for SFT is reused for PPO. To support the claim that the reward mechanism improves general tool use, please report performance on a held-out tool suite whose error categories or tool distributions differ from the reward taxonomy, or explicitly analyze how much of the gain is attributable to metric-aligned reward shaping.
  3. [Tables 2, 3, 5] Several headline comparisons rest on small absolute differences over very small test sets: RoTBench has 105 test instances, ToolAlpaca 114, BFCL-v3 239, and ToolEyes 382. For example, on RoTBench CF, TL-CodeLLaMA-2 (42.86) is 7.62 points above the average, which corresponds to about 8 of the 105 examples. With a single evaluation run using greedy decoding and no confidence intervals, bootstrap estimates, or multiple seeds, the paper's claim that the method 'matches or surpasses' state-of-the-art models is stronger than the reported evidence supports. Please add variance estimates, statistical tests, or multiple-seed training results for the main comparisons and the ablation table.
minor comments (3)
  1. [§5.4] The KL coefficient beta in the PPO objective in Section 4.3 is not reported in Section 5.4, and no sensitivity analysis is given for wmax (set to 9) or for the reward weights in Section 4.3, so the configuration is incompletely specified.
  2. [Appendix A, footnote 1] The Section 4 footnote claims 'theoretical proofs of the effectiveness' are provided, but Theorems A.1 and A.2 restate the loss definitions and show that gradients scale with weights, which is true by construction; they do not establish that the proposed changes improve downstream tool-use performance. The theoretical-justification claim should be softened or replaced with a substantive analysis.
  3. [§6.1, §8] There are minor language errors: 'maintaines' in Section 6.1 should be 'maintains', and 'a reward mechanism tailed for tool use' in Section 8 should be 'tailored for tool use'.

Circularity Check

2 steps flagged · score 5.0 of 10

ToolEyes multi-turn result is not independent: training data are generated from the ToolEyes tool foundation, and the appendix 'theorems' restate the loss definitions.

  1. fitted input called prediction [Section 5.1 / Table 2 / Appendix B (training data construction and ToolEyes test)]
    "Since ToolEyes provides a comprehensive set of invocable tools, we use it as a foundation to artificially create 1,217 relevant user requirements. GPT-4o is then employed to interact with these tools and generate the corresponding tool usage trajectories, which form our training set. ... ToolEyes is used for multi-turn tool use assessment."

    By construction, the training distribution is generated from the ToolEyes tool collection that is also the multi-turn test set. The paper never reports any filter, deduplication, or disjointness check between the 1,217 artificial requirements/trajectories and ToolEyes' 382 test queries. The ToolEyes scores (DE 0.82, CE 4.84, VA 77.75) can therefore be inflated by memorized tool schemas and interaction patterns; the claimed multi-turn 'prediction' is not an independent generalization measurement.

  2. self definitional [Appendix A, Theorems A.1 and A.2]
    "Tokens with higher weights w_m_s contribute more to the gradient: ... Therefore, assigning higher weights to key tokens during gradient updates enhances the model's performance on these tokens."

    The 'proof' of Theorem A.2 simply expands the weighted-loss definition L_PKT and observes that larger weights produce larger gradient magnitudes; it introduces no independent premise. The same holds for Theorem A.1, where MAE is defined as dropping erroneous calls and the proof concludes that dropping them removes their gradients. These results are true by definition of the losses, so they cannot serve as an external theoretical validation of the method; they are restatements rather than derivations.

full rationale

The single-turn evaluations (ToolAlpaca, RoTBench, BFCL-v3) use test distributions different from the training set and therefore provide legitimate external evidence for the method. However, the multi-turn ToolEyes result does not: Appendix B states that the 1,217 training trajectories were artificially created using ToolEyes as the tool foundation, and Table 2 lists the same ToolEyes benchmark (382 multi-turn cases) as the test set. No disjointness or deduplication analysis is reported, so the headline DE/CE/VA numbers on ToolEyes may largely reflect memorization of the tool schemas and interaction patterns in training rather than generalization. The PPO stage compounds this by reusing 1,194 of the same trajectories with a reward built from the same error taxonomy, but I do not count that as an independent circular step because the reward is a training proxy and the single-turn results remain external. The Appendix A 'theoretical proofs' are tautological restatements of the MAE/PKT loss definitions and provide no independent justification. Overall this is partial circularity confined mainly to the multi-turn claim; the single-turn results are self-contained.

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

The central results rest on hand-set weights and heuristics rather than learned or externally validated quantities. The most serious dependency is the possible overlap between training construction and the ToolEyes test set, which would undermine the multi-turn evaluation.

free parameters (3)
  • wmax (PKT token weight cap) = 9
    Hand-set in Section 4.2 and Section 5.4 with no sensitivity analysis showing how performance varies with the cap.
  • Reward weights for IRM = -2, -2, -1.5, -0.8, -0.5, -0.25, 1
    Hand-chosen in Section 4.3; no tuning procedure or ablation across reward values is reported.
  • PPO KL coefficient beta = not reported
    Mentioned in the PPO objective in Section 4.3, but no value is given in the implementation details.
assumptions (5)
  • domain assumption Erroneous tool-call paths can be reliably identified from tool feedback text.
    Section 4.1 relies on parsing feedback oi to extract Te; if feedback is ambiguous or the parser misses errors, masking is incomplete.
  • domain assumption The first token of a tool name and tokens sharing prefixes with other tool names are the key tokens determining selection accuracy.
    Section 4.2, motivated by Table 1 on two models; no independent test that these tokens are the only important ones.
  • domain assumption The error taxonomy in Figure 3 is complete enough to define rewards that improve tool use.
    Section 4.3 assigns a fixed reward per error category; categories are drawn from observed feedback, not proven exhaustive.
  • ad hoc to paper Training queries generated from ToolEyes tools are disjoint from ToolEyes test queries.
    Section 5.1 builds 1,217 trajectories from ToolEyes tools and Section 5.3 uses ToolEyes as the multi-turn test set; disjointness is not stated.
  • ad hoc to paper Excluding erroneous gradients and weighting key tokens improves downstream tool-use performance.
    Appendix A Theorems A.1 and A.2 only restate that gradients from errors teach errors and weighted tokens get more gradient; they do not prove end-task gains.

how reviews work

0 comments
Cite this review

Pith. "Pith review of TL-Training: A Task-Feature-Based Framework for Training Large Language Models in Tool Use." pith.science (2026). https://pith.science/paper/EY3PDNJB

@misc{pith2026241215495,
  author       = {Pith},
  title        = {Pith review of: TL-Training: A Task-Feature-Based Framework for Training Large Language Models in Tool Use},
  year         = {2026},
  howpublished = {\url{https://pith.science/paper/EY3PDNJB}},
  note         = {Machine review of arXiv:2412.15495}
}
read the original abstract

Large language models (LLMs) achieve remarkable advancements by leveraging tools to interact with environments, a critical step toward generalized AI. However, the standard supervised fine-tuning (SFT) approach, which relies on large-scale datasets, often overlooks task-specific characteristics in tool use, leading to performance bottlenecks. To address this issue, we analyze three existing LLMs and uncover key insights: training data can inadvertently impede tool-use behavior, token importance is distributed unevenly, and errors in tool calls fall into a small set of categories. Building on these findings, we propose~\emph{TL-Training}, a task-feature-based framework that mitigates the effects of suboptimal training data, dynamically adjusts token weights to prioritize key tokens during SFT, and incorporates a robust reward mechanism tailored to error categories, optimized through proximal policy optimization. We validate TL-Training by training CodeLLaMA-2-7B and evaluating it on four open-source test sets. Our results demonstrate that the LLM trained by our method matches or surpasses both open- and closed-source LLMs in tool-use performance using only 1,217 training data points. Additionally, our method enhances robustness in noisy environments and improves general task performance, offering a scalable and efficient paradigm for tool-use training in LLMs. Code and data are available at https://github.com/Junjie-Ye/TL-Training.

Figures

Figures reproduced from arXiv: 2412.15495 by the authors.

Figure 1
Figure 1. Error statistics for various tool calls in [PITH_FULL_IMAGE:figures/full_fig_p001_1.png] view at source ↗
Figure 2
Figure 2. Framework of TL-Training. TL-Training comprises three main components: (Left) mitigating the adverse effects of suboptimal data by identifying erroneous interaction trajectories through tool feedback and blocking their gradient updates; (Middle) optimizing key tokens by dynamically adjusting token weights during the SFT process; and (Right) enhancing tool call performance through a reward mechanism tailored to tool … view at source ↗
Figure 3
Figure 3. Types of errors encountered by LLMs during [PITH_FULL_IMAGE:figures/full_fig_p004_3.png] view at source ↗
Figures from the paper (1 more)
Figure 5
Figure 5. Figure 5: Performance comparison of CodeLLaMA-2 and TL-CodeLLaMA-2 across various general tasks. LLMs can accurately understand the functions and properties of different tools and execute effective invocations. We compare the performance of TL-CodeLLaMA-2 and RoTLLaMA across the…

Discussion (0). Continue with ORCID 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. AgentGym-RL: Training LLM Agents for Long-Horizon Decision Making through Multi-Turn Reinforcement Learning

    cs.LG 2025-09 conditional novelty 5.0 of 10

    Progressive reinforcement-learning horizon scaling lets a 7-billion-parameter open-source model match or surpass larger proprietary models on multi-turn agent tasks.

Reference graph

Works this paper leans on

37 extracted references · 7 canonical work pages · cited by 1 Pith paper

  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]

    Jinze Bai, Shuai Bai, Yunfei Chu, Zeyu Cui, Kai Dang, Xiaodong Deng, Yang Fan, Wenbin Ge, Yu Han, Fei Huang, Binyuan Hui, Luo Ji, Mei Li, Junyang Lin, Runji Lin, Dayiheng Liu, Gao Liu, Chengqiang Lu, Keming Lu, and 29 others. 2023. https://doi.org/10.48550/ARXIV.2309.16609 Qwen technical report . CoRR, abs/2309.16609

    arXiv doi:10.48550/arxiv.2309.16609 2023

  4. [4]

    Mark Chen, Jerry Tworek, Heewoo Jun, Qiming Yuan, Henrique Pond \' e de Oliveira Pinto, Jared Kaplan, Harri Edwards, Yuri Burda, Nicholas Joseph, Greg Brockman, Alex Ray, Raul Puri, Gretchen Krueger, Michael Petrov, Heidy Khlaaf, Girish Sastry, Pamela Mishkin, Brooke Chan, Scott Gray, and 39 others. 2021. https://arxiv.org/abs/2107.03374 Evaluating large ...

    arXiv 2021

  5. [5]

    Xuanting Chen, Junjie Ye, Can Zu, Nuo Xu, Rui Zheng, Minlong Peng, Jie Zhou, Tao Gui, Qi Zhang, and Xuanjing Huang. 2023. https://doi.org/10.48550/ARXIV.2303.00293 How robust is GPT-3.5 to predecessors? A comprehensive study on language understanding tasks . CoRR, abs/2303.00293

    arXiv doi:10.48550/arxiv.2303.00293 2023

  6. [6]

    Zehui Chen, Weihua Du, Wenwei Zhang, Kuikun Liu, Jiangning Liu, Miao Zheng, Jingming Zhuo, Songyang Zhang, Dahua Lin, Kai Chen, and Feng Zhao. 2024. https://arxiv.org/abs/2312.14033 T-eval: Evaluating the tool utilization capability of large language models step by step . Preprint, arXiv:2312.14033

    arXiv 2024

  7. [7]

    Karl Cobbe, Vineet Kosaraju, Mohammad Bavarian, Mark Chen, Heewoo Jun, Lukasz Kaiser, Matthias Plappert, Jerry Tworek, Jacob Hilton, Reiichiro Nakano, Christopher Hesse, and John Schulman. 2021. https://arxiv.org/abs/2110.14168 Training verifiers to solve math word problems . CoRR, abs/2110.14168

    arXiv 2021

  8. [8]

    Sreyan Ghosh, Chandra Kiran Reddy Evuru, Sonal Kumar, Ramaneswaran S., Deepali Aneja, Zeyu Jin, Ramani Duraiswami, and Dinesh Manocha. 2024. https://openreview.net/forum?id=XkHJo8iXGQ A closer look at the limitations of instruction tuning . In Forty-first International Conference on Machine Learning, ICML 2024, Vienna, Austria, July 21-27, 2024 . OpenReview.net

    work page 2024

Show all 37 references
  1. [9]

    Shibo Hao, Tianyang Liu, Zhen Wang, and Zhiting Hu. 2023. https://doi.org/10.48550/ARXIV.2305.11554 Toolkengpt: Augmenting frozen language models with massive tools via tool embeddings . CoRR, abs/2305.11554

    2023 doi arXiv

  2. [10]

    Dan Hendrycks, Collin Burns, Steven Basart, Andy Zou, Mantas Mazeika, Dawn Song, and Jacob Steinhardt. 2021. https://openreview.net/forum?id=d7KBjmI3GmQ Measuring massive multitask language understanding . In 9th International Conference on Learning Representations, ICLR 2021,...

    2021

  3. [11]

    Ilya Loshchilov and Frank Hutter. 2019. https://openreview.net/forum?id=Bkg6RiCqY7 Decoupled weight decay regularization . In 7th International Conference on Learning Representations, ICLR 2019, New Orleans, LA, USA, May 6-9, 2019 . OpenReview.net

    2019

  4. [12]

    Dheeraj Mekala, Jason Weston, Jack Lanchantin, Roberta Raileanu, Maria Lomeli, Jingbo Shang, and Jane Dwivedi - Yu. 2024. https://doi.org/10.18653/V1/2024.FINDINGS-EMNLP.289 TOOLVERIFIER: generalization to new tools via self-verification . In Findings of the Association for Co...

    2024 doi

  5. [13]

    OpenAI. 2023. https://doi.org/10.48550/ARXIV.2303.08774 GPT-4 technical report . CoRR, abs/2303.08774

    2023 doi arXiv

  6. [14]

    Patil, Tianjun Zhang, Xin Wang, and Joseph E

    Shishir G. Patil, Tianjun Zhang, Xin Wang, and Joseph E. Gonzalez. 2024. http://papers.nips.cc/paper\_files/paper/2024/hash/e4c61f578ff07830f5c37378dd3ecb0d-Abstract-Conference.html Gorilla: Large language model connected with massive apis . In Advances in Neural Information P...

    2024

  7. [15]

    Yujia Qin, Shengding Hu, Yankai Lin, Weize Chen, Ning Ding, Ganqu Cui, Zheni Zeng, Yufei Huang, Chaojun Xiao, Chi Han, Yi Ren Fung, Yusheng Su, Huadong Wang, Cheng Qian, Runchu Tian, Kunlun Zhu, Shihao Liang, Xingyu Shen, Bokai Xu, and 22 others. 2023. https://doi.org/10.48550...

    2023 doi arXiv

  8. [16]

    Yujia Qin, Shihao Liang, Yining Ye, Kunlun Zhu, Lan Yan, Yaxi Lu, Yankai Lin, Xin Cong, Xiangru Tang, Bill Qian, Sihan Zhao, Lauren Hong, Runchu Tian, Ruobing Xie, Jie Zhou, Mark Gerstein, Dahai Li, Zhiyuan Liu, and Maosong Sun. 2024. https://openreview.net/forum?id=dHng2O0Jjr...

    2024

  9. [17]

    Mengjie Ren, Boxi Cao, Hongyu Lin, Cao Liu, Xianpei Han, Ke Zeng, Guanglu Wan, Xunliang Cai, and Le Sun. 2024. https://doi.org/10.18653/V1/2024.ACL-LONG.330 Learning or self-aligning? rethinking instruction fine-tuning . In Proceedings of the 62nd Annual Meeting of the Associa...

    2024 doi

  10. [18]

    Baptiste Rozi \` e re, Jonas Gehring, Fabian Gloeckle, Sten Sootla, Itai Gat, Xiaoqing Ellen Tan, Yossi Adi, Jingyu Liu, Tal Remez, J \' e r \' e my Rapin, Artyom Kozhevnikov, Ivan Evtimov, Joanna Bitton, Manish Bhatt, Cristian Canton - Ferrer, Aaron Grattafiori, Wenhan Xiong,...

    2023 doi arXiv

  11. [19]

    John Schulman, Filip Wolski, Prafulla Dhariwal, Alec Radford, and Oleg Klimov. 2017. https://arxiv.org/abs/1707.06347 Proximal policy optimization algorithms . CoRR, abs/1707.06347

    2017 arXiv

  12. [20]

    Yifan Song, Weimin Xiong, Dawei Zhu, Cheng Li, Ke Wang, Ye Tian, and Sujian Li. 2023. https://doi.org/10.48550/ARXIV.2306.06624 Restgpt: Connecting large language models with real-world applications via restful apis . CoRR, abs/2306.06624

    2023 doi arXiv

  13. [21]

    Qiaoyu Tang, Ziliang Deng, Hongyu Lin, Xianpei Han, Qiao Liang, and Le Sun. 2023. https://doi.org/10.48550/ARXIV.2306.05301 Toolalpaca: Generalized tool learning for language models with 3000 simulated cases . CoRR, abs/2306.05301

    2023 doi arXiv

  14. [22]

    Meta Team. 2024. https://ai.meta.com/blog/meta-llama-3-1/ Introducing llama 3.1: Our most capable models to date

    2024

  15. [23]

    Nexusflow.ai team. 2023. https://nexusflow.ai/blogs/ravenv2 Nexusraven-v2: Surpassing gpt-4 for zero-shot function calling

    2023

  16. [24]

    Hugo Touvron, Louis Martin, Kevin Stone, Peter Albert, Amjad Almahairi, Yasmine Babaei, Nikolay Bashlykov, Soumya Batra, Prajjwal Bhargava, Shruti Bhosale, Dan Bikel, Lukas Blecher, Cristian Canton - Ferrer, Moya Chen, Guillem Cucurull, David Esiobu, Jude Fernandes, Jeremy Fu,...

    2023 doi arXiv

  17. [25]

    Mengru Wang, Yunzhi Yao, Ziwen Xu, Shuofei Qiao, Shumin Deng, Peng Wang, Xiang Chen, Jia - Chen Gu, Yong Jiang, Pengjun Xie, Fei Huang, Huajun Chen, and Ningyu Zhang. 2024. https://doi.org/10.48550/ARXIV.2407.15017 Knowledge mechanisms in large language models: A survey and pe...

    2024 doi arXiv

  18. [26]

    Mengsong Wu, Tong Zhu, Han Han, Chuanyuan Tan, Xiang Zhang, and Wenliang Chen. 2024. https://doi.org/10.48550/ARXIV.2405.08355 Seal-tools: Self-instruct tool learning dataset for agent tuning and detailed benchmark . CoRR, abs/2405.08355

    2024 doi arXiv

  19. [27]

    Zhiheng Xi, Wenxiang Chen, Xin Guo, Wei He, Yiwen Ding, Boyang Hong, Ming Zhang, Junzhe Wang, Senjie Jin, Enyu Zhou, Rui Zheng, Xiaoran Fan, Xiao Wang, Limao Xiong, Yuhao Zhou, Weiran Wang, Changhao Jiang, Yicheng Zou, Xiangyang Liu, and 10 others. 2023. https://doi.org/10.485...

    2023 doi arXiv

  20. [28]

    An Yang, Baosong Yang, Binyuan Hui, Bo Zheng, Bowen Yu, Chang Zhou, Chengpeng Li, Chengyuan Li, Dayiheng Liu, Fei Huang, Guanting Dong, Haoran Wei, Huan Lin, Jialong Tang, Jialin Wang, Jian Yang, Jianhong Tu, Jianwei Zhang, Jianxin Ma, and 43 others. 2024 a . https://doi.org/1...

    2024 doi arXiv

  21. [29]

    An Yang, Baosong Yang, Beichen Zhang, Binyuan Hui, Bo Zheng, Bowen Yu, Chengyuan Li, Dayiheng Liu, Fei Huang, Haoran Wei, Huan Lin, Jian Yang, Jianhong Tu, Jianwei Zhang, Jianxin Yang, Jiaxi Yang, Jingren Zhou, Junyang Lin, Kai Dang, and 22 others. 2024 b . https://doi.org/10....

    2024 doi arXiv

  22. [30]

    Zhaorui Yang, Tianyu Pang, Haozhe Feng, Han Wang, Wei Chen, Minfeng Zhu, and Qian Liu. 2024 c . https://doi.org/10.18653/V1/2024.ACL-LONG.58 Self-distillation bridges distribution gap in language model fine-tuning . In Proceedings of the 62nd Annual Meeting of the Association ...

    2024 doi

  23. [31]

    Junjie Ye, Xuanting Chen, Nuo Xu, Can Zu, Zekai Shao, Shichun Liu, Yuhan Cui, Zeyang Zhou, Chao Gong, Yang Shen, Jie Zhou, Siming Chen, Tao Gui, Qi Zhang, and Xuanjing Huang. 2023. https://doi.org/10.48550/ARXIV.2303.10420 A comprehensive capability analysis of GPT-3 and GPT-3...

    2023 doi arXiv

  24. [32]

    Junjie Ye, Guanyu Li, Songyang Gao, Caishuang Huang, Yilong Wu, Sixian Li, Xiaoran Fan, Shihan Dou, Tao Ji, Qi Zhang, Tao Gui, and Xuanjing Huang. 2025. https://aclanthology.org/2025.coling-main.12/ Tooleyes: Fine-grained evaluation for tool learning capabilities of large lang...

    2025

  25. [33]

    Junjie Ye, Sixian Li, Guanyu Li, Caishuang Huang, Songyang Gao, Yilong Wu, Qi Zhang, Tao Gui, and Xuanjing Huang. 2024 a . https://doi.org/10.18653/V1/2024.ACL-LONG.119 Toolsword: Unveiling safety issues of large language models in tool learning across three stages . In Procee...

    2024 doi

  26. [34]

    Junjie Ye, Yilong Wu, Songyang Gao, Caishuang Huang, Sixian Li, Guanyu Li, Xiaoran Fan, Qi Zhang, Tao Gui, and Xuanjing Huang. 2024 b . https://aclanthology.org/2024.emnlp-main.19 Rotbench: A multi-level benchmark for evaluating the robustness of large language models in tool ...

    2024

  27. [35]

    Junjie Ye, Yuming Yang, Qi Zhang, Tao Gui, Xuanjing Huang, Peng Wang, Zhongchao Shi, and Jianping Fan. 2024 c . https://doi.org/10.48550/ARXIV.2409.15825 60 data points are sufficient to fine-tune llms for question-answering . CoRR, abs/2409.15825

    2024 doi arXiv

  28. [36]

    Aohan Zeng, Bin Xu, Bowen Wang, Chenhui Zhang, Da Yin, Diego Rojas, Guanyu Feng, Hanlin Zhao, Hanyu Lai, Hao Yu, Hongning Wang, Jiadai Sun, Jiajie Zhang, Jiale Cheng, Jiayi Gui, Jie Tang, Jing Zhang, Juanzi Li, Lei Zhao, and 36 others. 2024. https://doi.org/10.48550/ARXIV.2406...

    2024 doi arXiv

  29. [37]

    Rossi, Somdeb Sarkhel, and Chao Zhang

    Yuchen Zhuang, Xiang Chen, Tong Yu, Saayan Mitra, Victor Bursztyn, Ryan A. Rossi, Somdeb Sarkhel, and Chao Zhang. 2023. https://doi.org/10.48550/ARXIV.2310.13227 Toolchain*: Efficient action space navigation in large language models with a* search . CoRR, abs/2310.13227

    2023 doi arXiv

Pith tools

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