How Language Models Learn to Use Tools Like Humans Do

Tool use has long been considered a defining hallmark of human intelligence. From the earliest stone implements to modern software, our species has extended its physical and cognitive reach by designing and manipulating instruments that solve problems beyond our native abilities. Neuroscientists have even identified specialized regions of the human brain, such as the anterior supramarginal gyrus, that activate uniquely during tool use, a capacity absent in our closest primate relatives. Now, a comprehensive new survey published in the open-access journal Vicinagearth argues that artificial intelligence is crossing a strikingly similar threshold. A team of researchers from Fudan University, East China Normal University, the University of Science and Technology of China, and the Institute of Artificial Intelligence at China Telecom has mapped out how large language models are learning to become genuine tool users, transforming them from passive text generators into active orchestrators of calculators, search engines, application programming interfaces, and far more.

The survey, led by Jinyang Chen, Haolun Wu, Jianhong Pang, and Yihua Wang with senior supervision from Dell Zhang and Changzhi Sun, provides the most systematic account to date of what the field calls tool learning. The core idea is deceptively simple: instead of expecting a language model to answer every question from its internal parameters, the model should learn to delegate parts of a problem to external tools that are faster, more accurate, or more current. When a user asks about tomorrow’s weather in Tokyo, the model should not hallucinate a forecast but call a live weather API. When a calculation involves more than trivial arithmetic, the model should hand the numbers to a code interpreter or symbolic solver. This reframing, the authors argue, turns tool use from physical manipulation into symbolic orchestration, where the language model acts as an intelligent controller that understands both what the user wants and what each tool can do.

At the heart of the survey lies a unified four-stage framework that the researchers use to organize the entire landscape: task planning, tool selection, task execution, and response generation. In the planning stage, the model decomposes a complex, high-level instruction into a series of smaller, solvable subtasks, working out the dependencies and the order in which they must run. Systems like ART build libraries of example tasks that guide this decomposition through few-shot prompts, while HuggingGPT combines specification-based instructions with demonstration parsing to schedule subtasks, and RestGPT refines its plans iteratively in a coarse-to-fine scheme as execution proceeds. Planning, the authors stress, is the cognitive foundation on which everything else depends, because a model that cannot break a problem down correctly will select the wrong tools or call them in the wrong order.

Tool selection is the second stage, and it presents a genuinely difficult engineering problem when the number of candidate tools reaches into the thousands. The survey distinguishes two dominant strategies. Retriever-based approaches first filter the tool library using semantic relevance, drawing on classical term-matching techniques such as TF-IDF and BM25 or on neural models like Sentence-BERT trained specifically for tool retrieval. Newer systems push this further: Craft asks the language model to generate hypothetical tool descriptions from a query and retrieve against them, while COLT applies graph neural networks and explicitly targets completeness of retrieval, ensuring no relevant tool is missed. When the candidate pool is small, LLM-based selection takes over, letting the model reason directly over tool descriptions. Methods like ToolBench combine fine-tuning with example retrieval and system prompts, while ToolVerifier generates comparative questions that force the model to distinguish between superficially similar tools, reducing misselection in ambiguous contexts.

Task execution, the third stage, is where natural language must be converted into structured, machine-readable calls. The survey illustrates this with a simple but revealing example: to convert 100 dollars into euros, the model must recognize that a currency API is required, extract the amount, source currency, and target currency, and emit a well-formed call such as convert with the appropriate named parameters. Getting this right demands schema-guided prompting, as in RestGPT and EasyTool, or more elaborate reasoning strategies like ReverseChain, which works backward from the desired final tool to infer the intermediate steps and parameters. Multi-agent architectures such as ToolNet and ConAgents divide the labor among specialized sub-agents that parse, plan, and execute, negotiating with each other over a shared backbone model. Meanwhile, instruction-tuned systems like Gorilla and ToolkenGPT, trained on massive tool-use corpora, generalize to unseen APIs with remarkable fluency, and verification modules such as ToolVerifier and Themis check proposed calls for validity before anything is actually executed, catching unsafe or ill-formed invocations early.

The final stage, response generation, determines how tool outputs are woven back into the model’s answer. The survey identifies two broad paradigms. Direct insertion methods, exemplified by TALM and Toolformer, embed the raw tool output at placeholder positions in the prompt and let the language model continue from there; Toolformer went further by fine-tuning on synthetic data in which API calls are interleaved with text, teaching the model when and where to invoke tools during generation. Information integration methods go deeper: ToolLLM routes tool outputs through a dedicated integration module before the main model composes its answer, ReCOMP compresses retrieved and computed information into latent representations for tighter factual grounding, and ConAgents lets multiple agents reinterpret tool results collaboratively before drafting the final response. The trade-off is clear: direct insertion is fast and simple, while deeper integration produces more coherent, context-sensitive answers in multi-tool scenarios.

Perhaps the most consequential part of the survey is its method-centric synthesis of how these capabilities are actually learned. Tuning-free approaches rely purely on prompt engineering and in-context demonstration, making them ideal for proprietary models that cannot be retrained and for rapid prototyping against unseen APIs; ReAct, which interleaves chain-of-thought reasoning with tool calls and incorporates environmental feedback, remains the canonical example. Supervised fine-tuning trains models on curated traces of tool interaction, from Toolformer’s self-generated annotations to ToolBench’s multi-stage datasets, with newer methods such as SFT-GO optimizing semantically important tokens separately and rehearsal-based strategies preventing catastrophic forgetting of general abilities. Reinforcement learning, however, is emerging as the frontier. ToolRL showed that fine-grained, step-level rewards outperform coarse final-answer signals and achieved up to a 17 percent improvement over supervised fine-tuning using Group Relative Policy Optimization. OTC penalizes unnecessary tool calls and cut tool usage by up to 73 percent while boosting productivity by 229 percent, and ReTool, which combines code execution with textual reasoning, reached 72.5 percent accuracy on the AIME mathematics competition, surpassing even OpenAI’s o1-preview baseline while exhibiting emergent self-correction.

Evaluation has matured alongside the methods. The survey reviews a rich ecosystem of benchmarks, from broad, coverage-oriented suites like ToolBench, API-Bank, and APIBench that test generalization across hundreds or thousands of APIs, to diagnostic instruments such as T-Eval, which scores six distinct dimensions of tool competence, and the Berkeley Function Calling Leaderboard, which measures structured invocation and agentic orchestration. Scenario-specific benchmarks probe the edges: ToolQA and ToolTalk test tool-grounded question answering in dialogue, ToolEmu simulates tools safely when real execution is too costly or risky, InjecAgent probes robustness against adversarial injection attacks, and SCITOOLBENCH and RoTBench examine scientific and symbolic tool chaining. The reported results paint a consistent picture. GPT-4-Turbo leads T-Eval with an overall score of 86.4, and the GPT-4 family dominates the GTA benchmark, yet the open-source xLAM series tops single-turn function calling on BFCL with accuracy up to 89.27, and the fine-tuned Lynx-7B model approaches GPT-3.5 performance on API-Bank, demonstrating that high-quality, ability-diverse training data can narrow the gap considerably.

The stakes extend well beyond leaderboards. The authors argue that tool learning makes language models more trustworthy and interpretable in concrete ways: intermediate tool invocations expose the reasoning path, standardized tool interfaces reduce sensitivity to prompt phrasing, and deterministic, externally verifiable tool outputs help suppress the hallucinations that have plagued large language models since their inception. In high-stakes domains such as finance, law, and healthcare, this traceability is not a luxury but a requirement. Tool integration also lets models engage with databases, scientific solvers, and medical systems, producing results that are domain-specific and checkable rather than merely plausible. This transparency and grounding, the survey contends, is what elevates tool learning from a convenient trick to a foundational capability that redefines what machine intelligence can credibly deliver.

Significant open challenges remain, and the survey is candid about them. Safety is paramount: hallucinated API calls or erroneous parameter choices in open-ended environments can produce dangerous or misleading outcomes, demanding runtime checks, input sanitization, and robust fallback strategies. Latency bottlenecks from multi-step, multi-tool pipelines strain user experience and scalability. Seamless multimodal integration across vision, speech, and structured data requires better interface design, and personalization, incorporating user preferences and history into tool selection, is still largely unsolved. The authors point toward multi-agent collaboration, LLM-driven tool creation in which models synthesize their own new functions, and unified abstraction frameworks that standardize model-tool interaction while enhancing generalization and safety. Richer benchmarks that simulate authentic, multi-stage, multimodal task scenarios are needed to capture the complexities of real-world use. If those challenges are met, the researchers conclude, tool learning will not merely augment language models but will stand as a foundational component of autonomous, transparent, and reliable artificial intelligence, marking the moment machines truly began to extend their own capabilities the way humans have extended theirs for millions of years.

Subject of Research: Tool learning with large language models, covering methods, pipelines, tuning strategies, and benchmarks for tool-augmented AI systems.

Article Title: Tool learning with language models: a comprehensive survey of methods, pipelines, and benchmarks

Article References: Tool learning with language models: a comprehensive survey of methods, pipelines, and benchmarks. (n.d.). https://doi.org/10.1007/s44336-025-00024-x

Image Credits: AI Generated

DOI: 10.1007/s44336-025-00024-x

Keywords: tool learning, large language models, artificial intelligence, reinforcement learning, supervised fine-tuning, API integration, benchmarks, task planning, hallucination, AI agents, natural language processing, foundation models