Traditionally, teaching a Large Language Model (LLM) to use a new software tool required fine-tuning the model on thousands of examples specific to that tool's API. However, a new paradigm is emerging: zero-shot tool generalization. Instead of memorizing specific command syntaxes, models are being trained to understand the underlying "grammar" of tool invocation. This allows them to interact with entirely unseen tools by simply reading their documentation at inference time.
From Memorization to Schema-Driven Reasoning
The core intuition behind this shift is that tool use is essentially a translation task. A model must map a user’s natural language intent to a structured schema (like JSON). By training models on the logic of this mapping rather than the specific tools, researchers have found that agents can generalize to novel interfaces.
For instance, Agarwal et al. in their work on the Granite-Function Calling Model demonstrate that breaking down function calling into granular sub-tasks—such as parameter extraction and call formatting—enables models to outperform much larger counterparts on unseen APIs. Similarly, Li et al. show in ModelScope-Agent that if a model is trained on the underlying logic of API schemas, it can integrate new tools via "schema registration" in the prompt, requiring no further training.
Learning from Execution and Introspection
Why does this generalization work? It works because the models are learning to reason about the consequences of their actions. Several frameworks focus on closing the loop between reasoning and execution.
- Execution Feedback: Qiao et al. introduced TRICE, which uses reinforcement learning to teach models not just how to call a tool, but when it is appropriate to do so based on real-world outcomes.
- Introspection: Gao et al. developed Confucius, a framework where the model "introspects" on its own confusion (measured by perplexity) to generate new training data, mastering complex tool scenarios through an easy-to-difficult curriculum.
- Evidence-Driven Synthesis: Rather than just predicting the next token, Chen et al. propose DIVE, which reverse-engineers tasks from successful tool execution traces. This "grounding by construction" ensures the model learns patterns that actually work in practice.
Cross-Domain Transfer of Agentic Logic
Perhaps the most striking finding is that tool-use logic is transferable across vastly different domains. A model trained to use a calculator or a code interpreter can apply that same "agentic logic" to medical imaging or web navigation.
Jiang et al. demonstrate this in the medical field with Ophiuchus, where a model trained on structured tool-invocation trajectories learns to autonomously probe images for clinical evidence using novel diagnostic tools. This suggests that the capacity for tool-augmented perception is a transferable reasoning skill.
This transferability is further explored by Li et al. in Chain-of-Agents, where agentic workflows developed in one area (like programming) are applied zero-shot to disparate tasks like information retrieval. The model relies on the semantic descriptions of the tools rather than domain-specific training.
Orchestration as a General Skill
As tasks become more complex, the challenge shifts from calling a single tool to orchestrating a workflow. Fan et al. argue in WorkflowLLM that orchestration—managing loops, branches, and multi-step actions—is a transferable skill rooted in structural logic.
To manage this complexity efficiently, Su et al. propose ToolOrchestra, which trains small models to act as "orchestrators." These models generalize to unseen tools and even other external LLMs by interpreting standardized descriptions, allowing for flexible, cost-effective scaling of agent capabilities.
By focusing on the shared patterns of documentation, invocation, and feedback, this research direction is moving us toward "Agent Foundation Models" that can navigate the software world as fluently as they navigate natural language.
Key Foundational Work
GPT4Tools: Teaching Large Language Model to Use Tools via Self-instruction (2023) — contributed 2 concept elements to this direction.
ModelScope-Agent: Building Your Customizable Agent System with Open-source Large Language Models (2023) — contributed 2 concept elements to this direction.
Making Language Models Better Tool Learners with Execution Feedback (2024) — contributed 2 concept elements to this direction.