Pith. sign in

REVIEW 4 major objections 6 minor 1 cited by

Enhancing Tool Learning in Large Language Models with Hierarchical Error Checklists

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

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

Pith's one-line read A two-tier error checklist—global and tool-specific—cuts parameter mis-filling in LLM tool calls, with the largest gains in smaller models.

desk verdict A useful, incremental recipe for tool-calling error correction that deserves refereeing, but the unvalidated generated negatives and a shaky theoretical inequality keep it from being more than conditional. read the letter →

arxiv 2506.00042 v1 pith:HENEXUEF submitted 2025-05-28 cs.CL

Yue Cui , Liuyi Yao , Shuchang Tao , Weijie Shi , Yaliang Li , Bolin Ding , Xiaofang Zhou This is my paper
classification cs.CL
keywords toollearningfunctioncallingerrorchecklistparametermis-fillingin-contextKahneman-Tverskyoptimizationpreferencelargelanguagemodels
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 most tool-calling failures in large language models can be anticipated and corrected without real API interaction, if errors are organized into a two-level checklist. HiTEC separates a global list of eight common error types from a local, tool-specific list generated from tool metadata. Deployed either as in-context prompting or as KTO fine-tuning on model-generated negative examples, the checklists improve F1 scores for both tool-name correctness and parameter correctness across five public datasets, with gains up to 42% and especially large jumps for 8B and smaller models. If true, the approach offers a cheap, interaction-free recipe for hardening function calling in small deployed models.

What carries the argument

The load-bearing object is the Hierarchical Tool Error Checklist, built from a global eight-item taxonomy and a local per-tool checklist that includes tool information, a simulated query for each error, a bad call, an error message, and a corrective reflection. The argument's second hinge is the asymmetric KTO loss: for a chosen response $y_w$ and a rejected response $y_l$ that differ at one token, the KTO gradient is $\nabla_\theta L_{\mathrm{KTO}} = -a_w \nabla_\theta \log \pi_\theta(y_w|x) + a_l \nabla_\theta \log \pi_\theta(y_l|x)$ with $a_w > a_l$, so minimizing the loss raises the probability of the correct token rather than merely widening a near-zero margin. That asymmetry is what makes fine-tuning on checklist-generated negative examples work where DPO-style preference optimization would stall.

What would settle it

Annotate a random sample of the PTC negative-example set: if many outputs contain extra deviations such as malformed JSON, missing closing brackets, or multiple injected errors, then the KTO training signal is not the clean checklist-based signal the paper claims.

Watch

Extended reading notes

Core claim

On its own terms, the paper's discovery is that a structured error taxonomy can reproduce much of the benefit of real tool interaction: a global checklist enumerating eight recurring failure modes (wrong tool name, missing or invalid or empty or redundant parameters, malformed output format, redundant text, wrong number of tools), plus a per-tool local checklist that pairs each error with a concrete failing call and a corrective thought. HiTEC-ICL injects the global checklist into the first prompt and the local checklist in a second correction round; HiTEC-KTO turns those checklists into synthetic negative examples and fine-tunes open models with Kahneman-Tversky Optimization. The paper further argues that KTO is the right tuner for this data because positive and negative tool calls differ by only a few tokens: DPO's gradient nearly vanishes and its training can lower the probability of the correct answer, while KTO's separate asymmetric weights push the correct token's logit upward. Empirically, HiTEC-KTO lets a 1.5B model surpass a 3B baseline in many settings and raises Llama3-8B's Name+Parameter F1 on Nexus Raven from 17.44 to 58.30.

Load-bearing premise

The approach assumes the generated negative examples are faithful: each corrupts exactly the intended checklist error and otherwise remains a valid tool call, and the manually chosen error types cover the mistakes models actually make.

Editorial extensions

If this is right

  • Fine-tuning with checklist-generated negatives lets 1.5B and 8B models reach or exceed larger baselines, so small on-device models become viable for function-calling agents.
  • Removing the local checklist cuts parameter accuracy far more than removing the global one, so the tool-specific error examples are the main driver of the reported gains.
  • KTO, rather than DPO or PPO, is the right objective for preference data in which chosen and rejected outputs differ by only a few tokens, a pattern that also arises in code repair and structured extraction.
  • HiTEC-ICL requires no fine-tuning and works from tool metadata alone, making it immediately applicable to new tools without execution logs.
  • The paper's multi-turn experiments show the error-checklist mechanism carrying over to iterative agent loops, with Llama3-8B F1 name rising from 8.24 to 43.01 on Seal-Tools.

Reading between the lines

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

  • The local checklists are generated automatically from tool metadata by a 72B instruct model, so the pipeline could be pointed at any API schema; a testable prediction is that gains on a new benchmark track the quality of those generated checklists.
  • The KTO failure-mode analysis likely transfers to other token-close preference datasets, such as typo-based code repair or SQL generation, where DPO would also suffer vanishing gradients.
  • The paper's appended limitation states that the error taxonomy is manually chosen and the feedback is simulated; an immediate extension is to refresh checklists from real execution logs, which would also test whether the eight categories match the errors that actually occur.
  • A self-contained variant in which a small model, not a 72B one, generates the negative examples remains untested; if it worked, the whole fine-tuning pipeline would need no large external generator.
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 introduces HiTEC, a hierarchical error checklist framework for improving LLM tool calling. It defines a global eight-item error checklist covering tool- and parameter-level mistakes, and per-tool local checklists with simulated queries, error messages, and correction thoughts. Two deployments are proposed: HiTEC-ICL, which injects the global checklist into the initial prompt and uses a two-round conversation with the local checklist to refine outputs, and HiTEC-KTO, which generates paired positive/negative tool-calling examples using the checklists and fine-tunes open-source models with KTO. Experiments on API-Bank, Tool-Alpaca, Seal-Tools, and Nexus Raven report F1 scores for tool-name accuracy and tool-name-plus-parameter accuracy, with claims of substantial gains for smaller models and a theoretical argument that KTO avoids DPO's failure modes on near-identical pairs.

Significance. If the empirical claims hold, HiTEC is a practical, interaction-free recipe for reducing parameter mis-filling in tool calling, and the comparison with DPO on a paired dataset with one-token differences is a useful case study. The evaluation uses five public benchmarks and an external F1 metric, so the central result is not circular relative to the checklist definitions. However, the significance is currently undercut by the absence of any uncertainty quantification, the lack of validation of the automatically generated negative examples, and several unresolved issues in the theoretical gradient analysis. The framework itself is simple and clearly described, and the paper explicitly acknowledges the limitation of simulated error feedback.

major comments (4)
  1. [§4.2, Tables 2–3; Table 1] The main claims of 'significantly improve' are not supported by statistical evidence. No error bars, seeds, or significance tests are reported; the test sets are very small (API-Bank L-2 has 127 queries, Tool-Alpaca 114, Nexus Raven 318), and several configurations show negligible or negative changes (e.g., Table 2, GPT-4-Turbo on Nexus Raven F1 Name drops from 94.13 to 92.81; Table 10, Llama3-8B on Seal-Tools F1 Name+Param drops from 82.51 to 81.93). At minimum, the paper should report variance across runs or a paired test to justify the word 'significant' in the conclusion.
  2. [§3.3.1, Appendix A; §4.2.2] The HiTEC-KTO negative examples are generated by Qwen2.5-72B-Instruct using the local error checklist, but the paper reports no validation, filtering statistics, or per-error distribution for the 12,000 samples drawn from xlam-function-calling-60k. This is not a purely hypothetical concern: Appendix E shows a model output in this pipeline containing code snippets and formatting errors that a trained reward model scored highly, illustrating that unvalidated generations can carry severe side effects. If the generated negatives contain malformed JSON or extra text, the KTO signal could teach format artifacts rather than checklist-driven correction, which would undermine the attribution of the reported gains to the error-checklist mechanism. Additionally, the local checklist template in Appendix A enumerates only Errors 2–7 and omits the global checklist's Wrong Tool Name (Error 0) and Wrong Number of Tools (Error 7); the resulting negative set is thus unlikely to contain tool-level errors, so part of the reported F1 Name improvements in §4.2.2 cannot be explained by the described checklist mechanism. The Limitation section concedes reliance on simulated error feedback but does not quantify whether that feedback is clean.
  3. [§3.3.3, Eq. (2)] The gradient weights in Eq. (2) are algebraically incorrect. Differentiating the KTO loss term -λ_w σ(β(rθ(x,yw)-z0)) gives a factor λ_w β σ(c_w)(1-σ(c_w)), not λ_w σ(c_w)σ(1-c_w), since σ'(c_w) = σ(c_w)(1-σ(c_w)); σ(1-c_w) is a different function. The same issue applies to al. This makes the displayed derivative in Eq. (2) formally wrong, and the subsequent claim that 'asymmetric weights provide stable gradients' is not justified by the derivation as written.
  4. [§3.3.3, Eq. (3) and following analysis] The sign analysis following Eq. (3) is not implied by aw > al. For the case tk = V_j, the gradient is -aw + al + aw s_j^{y<k_w,x} - al s_j^{y<k_l,x}, where the softmax terms lie in [0,1]; even with aw > al, the added term aw s_w - al s_l can be positive and exceed aw - al, so the gradient need not be negative. For tk ≠ V_j, the gradient aw s_w - al s_l can be negative. Thus the theoretical conclusion that KTO 'encourages an increase in the logits of the correct token' is not established. In addition, Eq. (3) treats aw and al as constants when rearranging the gradient token-wise, although they depend on θ through c_w and c_l; the paper does not state that this is an approximation.
minor comments (6)
  1. [Abstract and §4.2.1] The abstract reports 'up to 42%' improvement while the text reports 'over 30 points' on Nexus Raven; please clarify whether the abstract figure is relative or absolute and identify the specific comparison, since the point difference in Table 2 is 58.30 vs. 17.44 (40.86 points, not 42%).
  2. [Table 2] The entries for GPT-4-Turbo + Function Calling in the last two columns are backslashes instead of numeric values; these should be filled in or explicitly marked as unavailable.
  3. [Appendix D, Eq. (5)] The displayed DPO gradient has a typo: the second term inside the brackets should be log πθ(yl|x), not log πθ(yw|x), since the derivation is for the difference between chosen and rejected sequences.
  4. [Appendix A vs. Figure 3] The error numbering in the local checklist template is inconsistent with the global checklist: local 'Error 2: Missing Required Parameter Error' corresponds to global 'Error 1', and the local template skips tool-level errors entirely. This makes it difficult for readers to map local templates onto the global taxonomy.
  5. [Appendix E] The sentence 'Proximal Policy Optimization (PPO) is also a widely used method to xx' is incomplete, and 'not usefull' is a typo; these should be corrected.
  6. [§4.5, Tables 5–6] The cost analysis reports prompt and generated tokens but does not compare against the performance-per-token tradeoff quantitatively; the statement that the absolute expense is 'within a reasonable range' is subjective and would benefit from a per-point-of-F1 cost figure.

Circularity Check

0 steps flagged · score 0.0 of 10

No significant circularity: the central claims are evaluated on external benchmarks with external F1 metrics, and the KTO analysis is an independent mathematical derivation.

full rationale

The paper's central claim is that HiTEC-ICL and HiTEC-KTO improve tool-name and parameter-filling F1 scores on five public benchmarks. These metrics are computed against external gold tool calls, not against the paper's own checklist output. The global checklist is a fixed list of eight error types, and local checklists are generated from tool metadata via Qwen2.5-72B-Instruct using hand-authored templates in Appendix A; neither is fitted to the evaluation datasets. HiTEC-KTO's negative examples are generated from the external xlam-function-calling-60k ground-truth data and evaluated on disjoint benchmarks, so the reported gains are not defined by construction from the training signal. The theoretical comparison of KTO and DPO in Section 3.3.3 and Appendix D is a gradient-level derivation starting from the published KTO loss, not a restatement of the empirical results. No load-bearing self-citation appears: the cited prior work on DPO failure modes (Feng et al., Pal et al.) and KTO (Ethayarajh et al.) is external. The Limitation section's acknowledgment that simulated error feedback may limit generalizability is a validity caveat about negative-example quality, not evidence that the reported numbers reduce to the framework's own inputs. I therefore find no step where a prediction is equivalent to its inputs by construction, and the appropriate circularity score is 0.

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

The empirical claim rests on public benchmarks and an external F1 metric, but the training recipe depends on unreported KTO hyperparameters, a hand-built error taxonomy, and LLM-generated checklists and negatives whose quality is not measured. These unstated dependencies are the main reason the result is not yet fully auditable.

free parameters (3)
  • KTO hyperparameters beta, lambda_w, lambda_l = not reported
    The KTO loss in Eq. (1) depends on these; the paper never gives their values, although they control the scale of the gradient updates.
  • Global error checklist composition = 8 hand-chosen types
    The error types in Figure 3 are manually selected from prior experience; the number and wording are not derived from data.
  • KTO training subsample size = 12,000
    Section 4.2.2 says KTO is run on 12,000 samples from xlam-function-calling-60k; no justification is given for this subsample size or selection.
assumptions (4)
  • domain assumption The reference model pi_ref is fixed and z0 = KL(pi_theta || pi_ref) is treated as a constant during backpropagation.
    Section 3.3.3 states 'z0 does not propagate gradients' following Ethayarajh et al., but in the paired loss this is an approximation that can bias the update direction.
  • ad hoc to paper Positive and negative responses in the PTC dataset differ at only one token.
    Appendix D assumes this to derive the token-level gradient, but negative examples generated from checklists can differ from the ground truth in multiple tokens (e.g., wrong tool name plus missing parameter).
  • domain assumption The eight hand-crafted global error types cover the majority of tool-calling failures.
    The Limitation section acknowledges the checklist may not capture novel errors; the method's effectiveness depends on this coverage.
  • domain assumption The F1 Name + Parameter metric, defined in the Hammer preprocessing, correctly measures tool-calling success.
    All central results use this metric without an independent validation that it tracks real API execution success.

how reviews work

0 comments
Cite this review

Pith. "Pith review of Enhancing Tool Learning in Large Language Models with Hierarchical Error Checklists." pith.science (2026). https://pith.science/paper/HENEXUEF

@misc{pith2026250600042,
  author       = {Pith},
  title        = {Pith review of: Enhancing Tool Learning in Large Language Models with Hierarchical Error Checklists},
  year         = {2026},
  howpublished = {\url{https://pith.science/paper/HENEXUEF}},
  note         = {Machine review of arXiv:2506.00042}
}
read the original abstract

Large language models (LLMs) have significantly advanced natural language processing, particularly through the integration of external tools and APIs. However, their effectiveness is frequently hampered by parameter mis-filling during tool calling. In this paper, we propose the Hierarchical Tool Error Checklist (HiTEC) framework to systematically diagnose and mitigate tool-calling errors without relying on extensive real-world interactions. HiTEC introduces a two-tiered approach: a global error checklist that identifies common, cross-tool issues, and a local error checklist that targets tool-specific and contextual failures. Building on this structure, we propose two deployments: HiTEC-In Context Learning (HiTEC-ICL) and HiTEC-Kahneman-Tversky Optimization (HiTEC-KTO). HiTEC-ICL embeds the global checklist in the initial prompts and leverages a two-round conversational interaction to dynamically refine parameter handling, while HiTEC-KTO generates high-quality negative examples to drive fine-tuning via preference-based optimization. Extensive experiments across five public datasets demonstrate that our framework significantly improves parameter-filling accuracy and tool-calling success rates compared to baseline methods.

Figures

Figures reproduced from arXiv: 2506.00042 by the authors.

Figure 1
Figure 1. Pipeline of the Proposed Hierarchical Tool Error Checklist (HiTEC), which includes Global Error [PITH_FULL_IMAGE:figures/full_fig_p002_1.png] view at source ↗
Figure 2
Figure 2. The Local Error Checklist: a list of tool-specific issues that may arise during tool calling [PITH_FULL_IMAGE:figures/full_fig_p003_2.png] view at source ↗
Figure 3
Figure 3. The Global Error Checklist: a list of common [PITH_FULL_IMAGE:figures/full_fig_p003_3.png] view at source ↗
Figures from the paper (4 more)
Figure 4
Figure 4. Figure 4: An Example Conversation with the Global [PITH_FULL_IMAGE:figures/full_fig_p004_4.png]
Figure 5
Figure 5. Figure 5: Analysis on Error Distribution parable to its vanilla counterpart (w/o Glb-loc EC). Removing the local error checklist has a substan￾tial negative impact on HiTEC-KTO, as global er￾rors alone capture only general mistakes, whereas generating high-quality negative examp…
Figure 6
Figure 6. Figure 6: Effect of Error Types 4.4 Look Into the Errors In this subsection, we further look into errors and conduct error-level evaluations. 4.4.1 Analysis on Error Distribution We analyze error type distributions across the vanilla base model, HiTEC-ICL, and HiTEC-KTO configur…
Figure 7
Figure 7. Figure 7: Ablation Study on Error Types [PITH_FULL_IMAGE:figures/full_fig_p016_7.png]

Discussion (0). Sign in to comment.

Forward citations

Cited by 1 Pith paper

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

  1. Branch-and-Browse: Efficient and Controllable Web Exploration with Tree-Structured Reasoning and Action Memory

    cs.AI 2025-10 conditional novelty 5.0 of 10

    Branch-and-Browse, a tree-structured web agent with page-level action memory, reports 35.8% success and up to 40.4% less time than the cited Tree Search baseline on WebArena.

Reference graph

Works this paper leans on

32 extracted references · 8 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]

    Sijia Chen, Yibo Wang, Yi-Feng Wu, Qing-Guo Chen, Zhao Xu, Weihua Luo, Kaifu Zhang, and Lijun Zhang. 2024 a . Advancing tool-augmented large language models: Integrating insights from errors in inference trees. arXiv preprint arXiv:2406.07115

    arXiv 2024

  4. [4]

    Yanfei Chen, Jinsung Yoon, Devendra Singh Sachan, Qingze Wang, Vincent Cohen-Addad, Mohammadhossein Bateni, Chen-Yu Lee, and Tomas Pfister. 2024 b . Re-invoke: Tool invocation rewriting for zero-shot tool retrieval. arXiv preprint arXiv:2408.01875

    arXiv 2024

  5. [5]

    Kawin Ethayarajh, Winnie Xu, Niklas Muennighoff, Dan Jurafsky, and Douwe Kiela. 2024. Kto: Model alignment as prospect theoretic optimization. arXiv preprint arXiv:2402.01306

    arXiv 2024

  6. [6]

    Duanyu Feng, Bowen Qin, Chen Huang, Zheng Zhang, and Wenqiang Lei. 2024. Towards analyzing and understanding the limitations of dpo: A theoretical perspective. arXiv preprint arXiv:2404.04626

    arXiv 2024

  7. [7]

    Jiayi Fu, Xuandong Zhao, Chengyuan Yao, Heng Wang, Qi Han, and Yanghua Xiao. 2025. Reward shaping to mitigate reward hacking in rlhf. arXiv preprint arXiv:2502.18770

    arXiv 2025

  8. [8]

    Leo Gao, John Schulman, and Jacob Hilton. 2023. Scaling laws for reward model overoptimization. In International Conference on Machine Learning, pages 10835--10866. PMLR

    2023

Show all 32 references
  1. [9]

    Zhibin Gou, Zhihong Shao, Yeyun Gong, Yelong Shen, Yujiu Yang, Nan Duan, and Weizhu Chen. 2023. Critic: Large language models can self-correct with tool-interactive critiquing. arXiv preprint arXiv:2305.11738

    2023 arXiv

  2. [10]

    Zhicheng Guo, Sijie Cheng, Hao Wang, Shihao Liang, Yujia Qin, Peng Li, Zhiyuan Liu, Maosong Sun, and Yang Liu. 2024. Stabletoolbench: Towards stable large-scale benchmarking on tool learning of large language models. arXiv preprint arXiv:2403.07714

    2024 arXiv

  3. [11]

    Shibo Hao, Tianyang Liu, Zhen Wang, and Zhiting Hu. 2023. Toolkengpt: Augmenting frozen language models with massive tools via tool embeddings. Advances in neural information processing systems, 36:45870--45894

    2023

  4. [12]

    Edward J Hu, Yelong Shen, Phillip Wallis, Zeyuan Allen-Zhu, Yuanzhi Li, Shean Wang, Lu Wang, and Weizhu Chen. 2021. Lora: Low-rank adaptation of large language models. arXiv preprint arXiv:2106.09685

    2021 arXiv

  5. [13]

    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

  6. [14]

    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

  7. [15]

    Yanming Liu, Xinyue Peng, Yuwei Zhang, Jiannan Cao, Xuhong Zhang, Sheng Cheng, Xun Wang, Jianwei Yin, and Tianyu Du. 2024. Tool-planner: Dynamic solution tree planning for large language model with tool clustering. arXiv preprint arXiv:2406.03807

    2024 arXiv

  8. [16]

    Apigen: Automated pipeline for generating verifiable and diverse function-calling datasets

    Zuxin Liu, Thai Quoc Hoang, Jianguo Zhang, Ming Zhu, Tian Lan, Shirley Kokane, Juntao Tan, Weiran Yao, Zhiwei Liu, Yihao Feng, et al. Apigen: Automated pipeline for generating verifiable and diverse function-calling datasets. In The Thirty-eight Conference on Neural Informatio...

  9. [17]

    Arka Pal, Deep Karkhanis, Samuel Dooley, Manley Roberts, Siddartha Naidu, and Colin White. 2024. Smaug: Fixing failure modes of preference optimisation with dpo-positive. arXiv preprint arXiv:2402.13228

    2024 arXiv

  10. [18]

    Toolllm: Facilitating large language models to master 16000+ real-world apis

    Yujia Qin, Shihao Liang, Yining Ye, Kunlun Zhu, Lan Yan, Yaxi Lu, Yankai Lin, Xin Cong, Xiangru Tang, Bill Qian, et al. Toolllm: Facilitating large language models to master 16000+ real-world apis. In The Twelfth International Conference on Learning Representations

  11. [19]

    Changle Qu, Sunhao Dai, Xiaochi Wei, Hengyi Cai, Shuaiqiang Wang, Dawei Yin, Jun Xu, and Ji-Rong Wen. 2025. Tool learning with large language models: A survey. Frontiers of Computer Science, 19(8):198343

    2025

  12. [20]

    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

  13. [21]

    Zhengliang Shi, Shen Gao, Xiuyi Chen, Yue Feng, Lingyong Yan, Haibo Shi, Dawei Yin, Pengjie Ren, Suzan Verberne, and Zhaochun Ren. 2024. Learning to use tools via cooperative and interactive agents. arXiv preprint arXiv:2403.03031

    2024 arXiv

  14. [22]

    Yifan Song, Weimin Xiong, Dawei Zhu, Wenhao Wu, Han Qian, Mingbo Song, Hailiang Huang, Cheng Li, Ke Wang, Rong Yao, et al. 2023. Restgpt: Connecting large language models with real-world restful apis. arXiv preprint arXiv:2306.06624

    2023 arXiv

  15. [23]

    Venkat Krishna Srinivasan, Zhen Dong, Banghua Zhu, Brian Yu, Damon Mosk-Aoyama, Kurt Keutzer, Jiantao Jiao, and Jian Zhang. 2023. Nexusraven: a commercially-permissive language model for function calling. In NeurIPS 2023 Foundation Models for Decision Making Workshop

    2023

  16. [24]

    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

  17. [25]

    Boshi Wang, Hao Fang, Jason Eisner, Benjamin Van Durme, and Yu Su. 2024. Llms in the imaginarium: tool learning through simulated trial and error. arXiv preprint arXiv:2403.04746

    2024 arXiv

  18. [26]

    Jason Wei, Xuezhi Wang, Dale Schuurmans, Maarten Bosma, Fei Xia, Ed Chi, Quoc V Le, Denny Zhou, et al. 2022. Chain-of-thought prompting elicits reasoning in large language models. Advances in neural information processing systems, 35:24824--24837

    2022

  19. [27]

    Mengsong Wu, Tong Zhu, Han Han, Chuanyuan Tan, Xiang Zhang, and Wenliang Chen. 2024. Seal-tools: self-instruct tool learning dataset for agent tuning and detailed benchmark. In CCF International Conference on Natural Language Processing and Chinese Computing, pages 372--384. Springer

    2024

  20. [28]

    Hongshen Xu, Zichen Zhu, Lei Pan, Zihan Wang, Su Zhu, Da Ma, Ruisheng Cao, Lu Chen, and Kai Yu. 2024. Reducing tool hallucination via reliability alignment. arXiv preprint arXiv:2412.04141

    2024 arXiv

  21. [29]

    Rui Yang, Lin Song, Yanwei Li, Sijie Zhao, Yixiao Ge, Xiu Li, and Ying Shan. 2024. Gpt4tools: Teaching large language model to use tools via self-instruction. Advances in Neural Information Processing Systems, 36

    2024

  22. [30]

    Shunyu Yao, Jeffrey Zhao, Dian Yu, Nan Du, Izhak Shafran, Karthik Narasimhan, and Yuan Cao. 2022. React: Synergizing reasoning and acting in language models. arXiv preprint arXiv:2210.03629

    2022 arXiv

  23. [31]

    Easytool: Enhancing llm-based agents with concise tool instruction

    Siyu Yuan, Kaitao Song, Jiangjie Chen, Xu Tan, Yongliang Shen, Kan Ren, Dongsheng Li, and Deqing Yang. Easytool: Enhancing llm-based agents with concise tool instruction. In ICLR 2024 Workshop on Large Language Model (LLM) Agents

    2024

  24. [32]

    Yinger Zhang, Hui Cai, Xeirui Song, Yicheng Chen, Rui Sun, and Jing Zheng. 2023. Reverse chain: A generic-rule for llms to master multi-api planning. arXiv preprint arXiv:2310.04474

    2023 arXiv

Pith tools

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