
Date:2026-08-08
Who this is for: Have read LLM Reasoning, RAG, or Agent papers, and want to systematically understand tool calls, function calls, verifiable executions and agents for graduate students, new research and engineering background readers.
Abstract
The core problem of Tool-Using LLM is not to "make the model one more plug-in", but to let the model choose suitable actions, give legal parameters, read execution feedback, revise plans, and leave auditable evidence at the end. In the past few years, the route has roughly changed from ReAct's Reason-act-Observe Prompt, to the self-supervision tool of Toolformer to call learning, the large-scale API of ToolLLM / Gorilla Data and function calls are trained, and then to BFCL, ToolSandbox, tau-bench, APIGen-MT, MCP, etc., pay attention to the work of structured schema, state changes, and performing verification and multi-round interaction. This article gives a intensive reading route of the paper: when reading such papers, don't just ask "whether the model will call the tool", but should be split into six variables: tool selection, parameter generation, execution result utilization, state consistency, rejection, validator and reproducing experiment.
Contents
- Why is this topic important
- Core reading method: split the tool call into six problems
- A reading guide to the key papers
- A closer look at key papers
- Methods and experiments compared
- How to reproduce the results
- Common misconceptions
- Research questions for graduate students
- Summary
- References
Why is this topic important
The language model itself is just generating text. It can write "I will search the database" and "I will call the weather API", which does not mean that the task is really completed. The tool call research is concerned with the transformation from natural language intent to the external world action: which function to call, when to call, whether the parameters are in the schema, whether the execution result has been correctly absorbed, whether the task status has really changed, whether the tool is rejected or asked when the tool does not apply.
This is the boundary between Tool-Using LLM and normal quiz, RAG, and reasoning. RAG mainly retrieves external knowledge, and the tool call will change the environment or trigger the calculation; reasoning pays attention to the intermediate inference path, and the tool call also requires the actions in the path to be executed. An Agent may look very well planned, but just put user_id Fill in the wrong date, write the date format incorrectly, and call it hard when the necessary parameters are missing, which is ultimately a failure.
After 2025-2026, the focus of the research has shifted to "verifiable". BFCL advances the function call evaluation from a single round selection to AST matching, parallel calls, rejected calls and multistep agent settings; tau-bench makes agents Talk to simulate users in stateful environments such as retail, air travel, etc., and use the final database state to compare the target state; ToolSandbox emphasizes state dependence, dialogue interaction and dynamic milestones; APIGen-MT The multi-round tool data is constructed into executable, verifiable simulation interactions. For scientific research training, this direction is very suitable for practicing the ability of "from paper proposition to reproducible experiment", because each conclusion can be asked: Is the tool implemented? Is the state correct? Can failure be positioned?
Core reading method: split the tool call into six problems

First, how the tool interface is expressed. ReAct often uses natural language action in the early days; Toolformer inserts API calls into text; modern function calling is usually described using JSON schema, parameter types and tools. When reading the paper, the description of the tool is to be manually written, automatically extracted, or generated by the protocol or SDK. The stricter the schema, the easier it is to evaluate; the more open the tool description is, the easier it is for the model to hallucinate.
Second, where does the calling strategy come from? ReAct relies on a few example trajectories. Toolformer samples API calls and retains examples that lower the language modeling loss. ToolLLM draws on a large collection of tools from RapidAPI and automatically constructs solution paths. Gorilla and OpenFunctions use API documentation and call formats as training material. APIGen and APIGen-MT emphasize checking synthetic data through execution, format validation, and semantic validation. When comparing these approaches, distinguish what the prompt elicits, what the SFT data teaches, and what the execution environment makes possible.
Third, whether the tool selection and parameter generation are evaluated separately. The model is the right tool but the parameters are wrong, and the wrong tool is selected but the format is correct, there are two types of failures. One of the values of BFCL is to include scenarios such as multilingual, parallel calls, multi-function candidates, and correlation detection. When taking reading notes, it is recommended to write a column in each paper: it mainly tests Tool Selection, Argument Filling, Multi-Step Planning, State Tracking, or Final Outcome.
Fourth, how the tool results go to the next reasoning. A true agent isn't just "one call". It reads Observation, updates working memory, and determines whether to continue calling, changing tools, asking users or stopping. The difficulty of multi-round environments such as tau-bench, ToolSandbox, and APIGen-MT is here: the model may be correct in the first few steps, and finally fails because of forgetting policy constraints, ignoring the database state or incorrectly absorbing the API return.
Fifth, the evaluation is whether to execute or approximate execution. The weakest evaluation is to let another LLM judge whether the call is reasonable; what is more reliable is the AST/Schema matching; further is the actual execution function, checking the return value, database status, file system change or task target. The credibility of each paper is largely dependent on its verification signal. If the tool itself is a Live API, also check whether the API version, network fluctuations, permissions, and data change over time.
Sixth, where is the security border. Tool calls turn model output into actions, so you must read rejected calls, permissions, user acknowledgments, error handling, and audit logs. Both the MCP specification and the mainstream Agents SDK use the tools schema, call control and manual confirmation as a system design problem, rather than relying solely on the model to "consciously". When scientific research is reappeared, the security boundary can be simplified, but cannot disappear from the problem definition.
A reading guide to the key papers
| Stage | Representative work | What to look for as you read |
|---|---|---|
| Reasoning - Action Interlace | ReAct | Thought-action-observation track, whether the error can be diagnosed manually |
| Self-Supervision Tools Learning | Toolformer | Which API calls are sampled and how to filter "helpful" calls |
| multimodal / open tool training | GPT4Tools, ToolLLM | How to synthesize instruction data, how to evaluate see/unseen tools |
| API function call special training | Gorilla, OpenFunctions, xLAM/APIGen | API documentation, Schema, Retriever, synthetic data and perform validation |
| function call benchmark | BFCL, ACEBench | AST match, parallel call, reject call, multi-round and incomplete instruction |
| Stateful Agent Reviews | ToolSandbox, tau-bench, APIGen-MT | User simulation, status transfer, pass^k, database target state |
| protocol and runtime | MCP, Agents SDK, terminal-use benchmarks | Tool discovery, permissions, logs, real environment execution and reproducibility |
This table is not a paper ranking, but a coordinate system when reading literature. If a new job claims to be "improve the tool use", first judge that it changes the interface, training data, retrieval, call format, executor, environment simulation, or evaluation protocol.
A closer look at key papers
ReAct. ReAct's contribution is to interleave the Reasoning traces and task-specific actions, so that the model can loop between "thinking one step, one step, and looking back". Do not stop in the Prompt template during intensive reading, but look at four types of tasks: HotpotQA, FEVER, ALFWorld, and WebShop, respectively, represent knowledge retrieval, factual verification, interactive environment and web shopping. Reproduction can start with a small Wikipedia search or WebShop-like environment, focusing on whether the action has changed the Observation, and whether the error can be positioned through the trajectory.
Toolformer. Toolformer rewrites the tool to rewrite the language modeling data filtering problem: first give a few API examples, and then let the model sample the possible calls in the text, execute the tools, and keep the calls that can improve the subsequent token prediction. The most worth learning is the training idea of "no need for a lot of manual tool trajectories". When reading, ask: Are the preserved calls really helpful to the task? Is the gain mechanism the same for different tools such as search, calculator, translation, calendar, etc.?
ToolLLM / ToolBench. ToolLLM zooms in to the real API collection, using API collection, instruction generation, solution labeling, and ToolEval review. It is suitable for training you to read data construct papers: where the API comes from, whether the category is balanced, whether the automatic annotation is verifiable, and how the generalization of the unseen API is defined. Note that when ToolBench relies on real APIs, it is easy to encounter API failure and non-reproducing problems, so follow-up work often introduces virtual APIs or executable sandboxes.
Gorilla and BFCL. Gorilla connects LLMs to a large collection of APIs and aims to reduce hallucinated calls. BFCL provides a more standardized benchmark for function calling. Examine its evaluation design. Why is abstract syntax tree (AST) matching more robust than string matching? How does the benchmark distinguish serial, parallel, and multiple function calls? How does it test whether a model can recognize an irrelevant function and decline to call it? Both the 2025 ICML/PMLR version and the Berkeley project page show how BFCL has expanded beyond single-turn calls to more agentic settings. Rankings and model versions on the live leaderboard change quickly, so record the retrieval date and flag details that still need manual verification when writing a paper or blog post.
tau-bench. The core of tau-bench is not a few more tools, but puts tool calls into user conversations and business rules. It uses a simulated user to talk to the Agent, the Agent calls the API and abides by the policy, and finally compares the database status and target state, and also proposes pass^k to measure the consistency of multiple runs. When reading this article, you should focus on two things: first, the success of the task is not "the answer sounds right", but the environmental state is really right; second, whether the same task runs multiple times is stable, which is closer to reliability than one success.
ToolSandbox and APIGen-MT. ToolSandbox further emphasizes stateful, conversational, interactive: there are implicit state dependencies between tools, and user information may be given in multiple rounds, and the evaluation includes intermediate milestones and minefield. APIGen-MT solves the problem of data scarcity of multiple rounds from the perspective of data generation: Mr. makes a verifiable task blueprint, simulates the human-agent-environment trajectory, and filters it with execution and semantic checking. The two are suitable for reading together: one tells you what a good evaluation environment looks like, and one tells you how to synthesize multiple rounds of training data.
MCP with modern Agents SDK. Protocols and SDKs are not traditional papers, but are important for tool invocation studies for 2025-2026. MCP standardizes how the tool is exposed to the model, the tool contains the name, description and schema; the OpenAI Agents SDK and other runtimes put hosted tools, function tools, MCP servers, error handling, approval and Tracing is put into a unified agent loop. The purpose of reading these materials is not to learn a product, but to understand how research experiments are gradually getting closer to the real runtime: tool discovery, permissions, logs, and auditability can affect the results.
Methods and experiments compared
| Method | main variable | suitable for tasks | Recover risk |
|---|---|---|---|
| ReAct prompting | Sample trajectory, action format, observation design | Search Q&A, web navigation, small interactive environment | Prompt leak, the track format is fragile |
| Toolformer self-supervision | API example, sample location, execution result, loss filter | Calculation, retrieval, translation, calendar and other tools | The "help" signal may only be adapted to the local fabric |
| Tool instruction tuning | API documentation, synthesis instructions, solution path | Large toolset, SEEN/UNSEEN API generalization | Automatic labeling errors and real API failures |
| Function calling SFT | schema, parameter type, rejection sample | Project function calls, parallel calls | Only learn format, not task status |
| AST/Schema Review | parser, equivalent rule, parameter tolerance | Large-scale function call leaderboard | There is still a gap with the real execution results |
| Stateful sandbox | User simulation, database status, milestones | Customer service, schedule, file, terminal tasks | The environmental construction cost is high, and the task design needs to be manually reviewed |
| MCP/agent runtime | Tool discovery, permissions, logs, error handling | Real Agent Systems and Long Term Experiments | The version changes fast and requires locking protocols and dependencies |
When reading the experimental table, record at least four types of indicators: call format Accuracy, tool selection Accuracy, task final success rate, stability or pass^k. Only the Final Answer or LLM Judge scores are reported, and the tool call capability cannot be described.
How to reproduce the results
Do not start repeating the full tau-bench or BFCL. More suitable for training camp is to build a small executable tool-use lab.
- Define 10-20 local functions. For example, query the curriculum, read and write JSON databases, calculate statistics, generate files, and check dates. Each function writes the schema, parameter type, error return, and permissions.
- Construct 100 tasks. Covering single tools, multi-tools, parallel tools, missing parameters, error parameters, no suitable tools, needs to be asked, and needs to be rejected.
- Implement three baselines. Direct Answer, ReAct Text Action, Structured Function Calling. All baselines use the same model, the same task set, and the same actuator.
- Design execution validator. Don't just look at the model output. Check the function call sequence, parameter, return value utilization, final database or file status for each question.
- Record the full log. Save Prompt, Model, Temperature, Tool Schema, Messages per Round, Tool Call, Tool Output, Error Stack, Final Status, and Rating Script Versions.
- Do Failure Taxonomy. At least distinguish: the tool selection is wrong, the parameters are wrong, the missing parameters are not asked, the call order is wrong, the Observation is ignored, the status update is wrong, the call should be rejected, and the format resolution failed.
- Do ablation. Remove tool description details, disrupt the order of tools, add similar tools, add irrelevant tools, limit the maximum number of invocation steps, and observe how the failure type changes.
In the end, reproduction report does not have to pursue the score of the big list, but can answer a research question: which types of errors are reduced in structured schema, execution feedback and status verification?
Common misconceptions
- Use the "energy output function name" as a knowledge tool. True tool calls also include parameters, sequence, execution feedback, and final state.
- Measure only single wheel clean commands. Real users often lack parameters, change requirements, say wrong information or request more rights; these are the key difficulties of the tool agent.
- Confusing retrieval and action. Search is a kind of tool, but writing databases, placing orders, sending emails, and changing files requires stronger permissions and verification.
- Use the Live API for non-reproducible experiments. The API version, quota, network and data will change. Serious reproduction should prioritize Mock Server, Fixture, or local Sandbox.
- Ignore the rejection call. A good tool Agent is not only called multiple calls, but also knows when to not call, ask or ask for manual confirmation.
- Superstitious leaderboard ranking. BFCL, tau-bench, and MCP related lists are updated very quickly, and the specific model ranking must be checked according to the search date, and cannot be written into a long-term conclusion.
Research questions for graduate students
- Tool description robustness. System Study Schema describes the effect of length, parameter examples, error prompts, and tool order on the result of the call.
- Reject the call to the dataset. Construct samples of missing parameters, overpower, no tools available, and tool outcome conflicts, and the evaluation model should be stopped or asked.
- Perform feedback learning. Compare the contributions of the subsequent SFT/RL with only the final state, the full trajectory, the error stack, and the manual Failure Label.
- Status compression memory. In the multi-round tool task, which states must remain in the context and which can be restored by requery.
- The tool calls the Reward Model. Investigate whether the Reward Model can recognize parameter errors, sequential errors, and invalid calls, rather than just preferences for smooth interpretation.
- MCP-enabled agent benchmark. Design small and realistic tasks on a controllable local MCP Server, and evaluate tool discovery, permission confirmation, and log auditing.
Summary
The main line of the research of Tool-Using LLM can be summarized as: first use ReAct to interleave thinking and action, and then use Toolformer/ToolLLM/Gorilla to let the model learn the API format and large-scale tools collection, and finally use BFCL, ToolSandbox, tau-bench, APIGen-MT, MCP and real runtime push "will call" to "verifiable, auditable, reproducible". When reading such papers, the most important thing is not to remember the first of a list, but to establish a set of inspection frameworks: whether the interface is structured, whether the call is executed, whether the status is correct, whether the failure can be locate, whether the authority is controllable, and whether the experiment can run again in the future.
If you read only five articles, it is recommended to start with ReAct, ToolLLM, BFCL, Tau-bench; if you want to make a small topic that can be published, then start from the local sandbox and failure taxonomy start. A tool call is not the whole of the Agent, but it is the path that the Agent is most likely to be strictly verified when it goes from "speaking" to "will do".
References
Search date: 2026-08-08.
- Shunyu Yao et al. “ReAct: Synergizing Reasoning and Acting in Language Models.” Project page, arXiv 2022, ICLR 2023. https://react-lm.github.io/
- Timo Schick et al. “Toolformer: Language Models Can Teach Themselves to Use Tools.” NeurIPS 2023. https://proceedings.neurips.cc/paper/2023/hash/d842425e4bf79ba039352da0f658a906-Abstract-Conference.html
- Rui Yang et al. “GPT4Tools: Teaching Large Language Model to Use Tools via Self-instruction.” NeurIPS 2023. https://papers.neurips.cc/paper_files/paper/2023/hash/e393677793767624f2821cec8bdd02f1-Abstract-Conference.html
- Yujia Qin et al. “ToolLLM: Facilitating Large Language Models to Master 16000+ Real-world APIs.” ICLR 2024. https://proceedings.iclr.cc/paper_files/paper/2024/hash/28e50ee5b72e90b50e7196fde8ea260e-Abstract-Conference.html
- Shishir G. Patil et al. “Gorilla: Large Language Model Connected with Massive APIs.” Project page and official GitHub. https://gorilla.cs.berkeley.edu/ ; https://github.com/ShishirPatil/gorilla/
- Shishir G. Patil et al. “The Berkeley Function Calling Leaderboard (BFCL): From Tool Use to Agentic Evaluation of Large Language Models.” ICML 2025, PMLR. https://proceedings.mlr.press/v267/patil25a.html
- Berkeley Sky Computing Lab. “Berkeley Function-Calling Leaderboard.” Project page, updated 2025. https://sky.cs.berkeley.edu/project/berkeley-function-calling-leaderboard/
- Shunyu Yao et al. “tau-bench: A Benchmark for Tool-Agent-User Interaction in Real-World Domains.” ICLR 2025. https://proceedings.iclr.cc/paper_files/paper/2025/hash/1b126cc38b8638e07bef37e7b2bb72bf-Abstract-Conference.html
- tau-bench official site and benchmark evolution notes. https://taubench.com/
- Jiarui Lu et al. “ToolSandbox: A Stateful, Conversational, Interactive Evaluation Benchmark for LLM Tool Use Capabilities.” arXiv 2024; official repository linked in paper. https://arxiv.org/abs/2408.04682 ; https://github.com/apple/ToolSandbox
- Zuxin Liu et al. “APIGen: Automated Pipeline for Generating Verifiable and Diverse Function-Calling Datasets.” arXiv 2024; project page. https://arxiv.org/abs/2406.18518 ; https://apigen-pipeline.github.io/
- Akshara Prabhakar et al. “APIGen-MT: Agentic Pipeline for Multi-Turn Data Generation via Simulated Agent-Human Interplay.” arXiv 2025; project page. https://apigen-mt.github.io/
- Zhengliang Shi et al. “Tool Learning in the Wild: Empowering Language Models as Automatic Tool Agents.” WWW 2025, OpenReview. https://openreview.net/forum?id=T4wMdeFEjX
- OpenAI Help Center. “Function Calling in the OpenAI API.” Updated 2026. https://help.openai.com/en/articles/8555517
- OpenAI Agents SDK. “Tools.” Official documentation. https://openai.github.io/openai-agents-python/tools/
- Model Context Protocol. “Tools.” Specification 2025-06-18. https://modelcontextprotocol.io/specification/2025-06-18/server/tools
- TUA-Bench. “A Benchmark for General-Purpose Terminal-Use Agents.” Official site, arXiv citation shown on page. https://tuabench.ai/
- Huanzhi Mao et al. “MFCL Vision: Benchmarking Tool Use in Multimodal Large Language Models for Visual Reasoning Tasks.” NeurIPS 2025 Workshop, OpenReview. https://openreview.net/forum?id=vV4tC5rhw6