Empowering LLM-based Agents: Methods and Challenges in Tool Use
Problem Statement
An LLM's internal knowledge is frozen at training time. That limits agents on tasks that need current data, exact computation, or actions in external environments. Tool use addresses this, but the literature is fragmented, and deployment-critical failures (knowledge conflicts, long-context degradation, scaling surprises, security holes) have not been organized in one place.
Key Novelty
- An evolutionary taxonomy of tool use that moves from foundational agent architectures, through core invocation mechanisms (function calling), to advanced strategies such as dynamic tool retrieval and autonomous tool creation
- A consolidated set of under-discussed failure modes: conflicts between parametric priors and retrieved or tool evidence, performance collapse in long contexts, and non-monotonic scaling in compound (multi-call or multi-agent) systems
- An explicit treatment of new security vulnerabilities that tool-augmented agents introduce, combined with a proposed research agenda for capable, secure, and reliable agents
Evaluation Highlights
- Qualitative synthesis from a systematic literature review; the paper reports no new empirical benchmarks or experiments
- Identifies four critical challenge categories: knowledge conflicts, long-context degradation, non-monotonic scaling of compound systems, and security vulnerabilities
Signal Assessment
Methodology
- Run a systematic literature review of LLM-based agent and tool-use research
- Organize methods along an evolutionary axis: agent architectures, function calling and invocation, tool retrieval, tool creation
- Analyze the reviewed work to extract recurring failure modes and deployment obstacles
- Synthesize the findings into a forward-looking research agenda focused on capability, security, and reliability
System Components
Core agent designs (e.g., reasoning-acting loops, planning, memory modules) that give the LLM a structure for deciding when and how to act
Structured interfaces, typically JSON schemas or API specs, through which the LLM emits executable tool calls and takes in their outputs
Retrieval-based selection of relevant tools from large toolsets at inference time, which avoids context overflow from listing every tool
Agents that write new tools (e.g., code functions) when existing ones are insufficient, then reuse them
Covers knowledge conflicts, long-context degradation, non-monotonic scaling in compound systems, and security threats such as prompt injection through tool outputs
Proposed future directions for making tool-using agents more capable, secure, and reliable
Results
| Metric/Benchmark | Baseline | This Paper | Delta |
|---|---|---|---|
| Knowledge access | Static parametric LLM knowledge | Tool-augmented access to dynamic data | Qualitative: overcomes knowledge cutoff |
| Tool scalability | Fixed tool list in prompt | Dynamic tool retrieval | Qualitative: supports large toolsets |
| Tool coverage | Predefined human-made tools | Autonomous tool creation | Qualitative: open-ended capability extension |
| Long-context robustness | Short-context tool use | Long-context scenarios surveyed | Reported significant degradation (open challenge) |
| Compound system scaling | Single LLM call | Multi-call or compound systems | Non-monotonic: more calls do not always help |
Key Takeaways
- Don't assume that more LLM calls or more agents improve results. Compound systems can scale non-monotonically, so tune the number of calls and the aggregation strategy empirically for each task.
- Use tool retrieval instead of putting every tool schema in the prompt. Long-context degradation significantly hurts tool-selection accuracy as toolsets grow.
- Design explicitly for conflicts between the model's priors and tool outputs, using source attribution, confidence checks, or prompting that prioritizes evidence. Treat tool outputs as untrusted input to defend against injection-style security attacks.
Abstract
The emergence of Large Language Model (LLM)-based agents marks a significant step towards more capable Artificial Intelligence. However, the effectiveness of these agents is fundamentally constrained by the static nature of their internal knowledge. Tool use has become a critical paradigm to overcome these limitations, enabling agents to interact with dynamic data, execute complex computations, and act upon the world. This paper provides a comprehensive survey of the methods, challenges, and future directions in empowering LLM-based agents with tool-use capabilities. Through a systematic literature review, we synthesized the current state of the art, charting the evolution from foundational agent architectures and core invocation mechanisms like function calling to advanced strategies such as dynamic tool retrieval and autonomous tool creation. Our analysis revealed several critical challenges that impede the deployment of robust agents, including knowledge conflicts between internal priors and external evidence, significant performance degradation in long-context scenarios, non-monotonic scaling behaviors in compound systems, and novel security vulnerabilities. By mapping the current research landscape and identifying these key obstacles, this survey proposes a research agenda to guide future efforts in building more capable, secure, and reliable AI agents.