Enhancing Tool Learning in Large Language Models with Hierarchical Error Checklists (2025)

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.

## introduction large language models (llms) have revolutionized natural language processing by enabling advanced comprehension, reasoning, and task execution capabilities. among these, the integration of external tools and application programming interfaces (apis) represents a critical milestone, allowing llms to expand their utility beyond textual analysis into interactive, task-oriented domains @xcite @xcite @xcite @xcite . to achieve this, llms must navigate a complex process of function calling, which involves selecting the appropriate tools, formulating precise input arguments, and parsing results to satisfy tool input. despite these advancements, tool-calling often suffers from incorrect parameter filling @xcite , a recurring issue that undermines the accuracy and reliability of llm-driven interactions. most previous tool learning methods require llm-tool interactions to improve the calling accuracy @xcite @xcite @xcite @xcite . for example, ste @xcite simulate plausible scenarios and incorporates execution feedback to enhance the correct use of tools. it involves first simulating queries, executing real tool calls via tool-llm interactions, and learning from function calling outputs when errors occur. while real-world interactions with tools can yield valuable insights, they cause intensive resources (for example, 10-25$/1,000 transactions for bing search api foot_0 ) and instability issues @xcite . furthermore, the errors encountered by most tools called by llms are predominantly common types that can be known in advance before real tool calling. to address these challenges, we argue that (1) tool-llm interactions that involve real-world tool callings are not always necessary, and (2) structured error checklists can systematically identify potential performance deficiencies and guide targeted improvements. based on this motivation, this paper proposes a hierarchical tool error checklist (hitec) framework to enhance tool learning with llms by identifying and addressing tool-calling errors. as shown in figure 1 , the hitec framework is composed of the constructions of two levels of error checklists: a global error checklist, which captures general errors that frequently occur across different tools, ## related work llm-based tool learning methods can be generally categorized into tuning-free and tuning-based approaches @xcite . tuning-free methods leverage the inherent capabilities of large language models by prompting them to interact directly with external tools. this category includes techniques such as few-shot demonstrations @xcite , rule-based strategies @xcite @xcite , and the use of optimized tool descriptions @xcite to facilitate efficient parameter extraction and tool usage. owing to their simplicity and scalability, tuning-free methods have gained popularity; however, their performance often lags behind that of tuning-based approaches and a finally correct tool calling may require multiple times of tool-llm interactions, which can be costly. in contrast, tuning-based methods enhance tool calling performance through fine-tuning strategies. gpt4tools @xcite uses lora-based supervised fine-tuning, while the introduction of tool-specific tokens is demonstrated in toolkengpt @xcite . other approaches leverage augmented datasets @xcite , and utilize interactive path-based reasoning @xcite to improve tool interaction precision. relign @xcite tackles tool hallucinations (also incorrect tool selection/usage) by expanding the action space with "indecisive actions" (e.g., deferring tool use) and aligning reliability via preference optimization. although tuning-based methods consistently deliver superior performance by tailor-please read the following error checklist. error 0: wrong tool name error … error 2: missing required parameter error query: the weather of 37°47′n 122°25′w on jan 1st 2025 function calling output: [{{"name": weather_api,"arguments": {{"lon":37.47,"lat":125.25}}}}] error message: {{"error": "missingrequiredparameter","message": "the parameter "time" is required."}} thought of error: parameter "time" is missing. ensure all required parameters ("lat", "lon","time") are included in the function call. ## method in this section, we introduce the novel hierarchical tool error checklist (hitec) framework, comprising global and local error checklists to address parameter mis-filling in tool learning. we propose both tuning-free (hitec-icl) and tuning-based (hitec-kto) methods to integrate hitec into llms, enabling dynamic error reflection and correction based on pre-identified patterns and toolspecific information.