AutoTool: Efficient Tool Selection for Large Language Model Agents

AI summary

Overview

Research area: LLM agent efficiency — specifically, reducing the inference cost of tool selection in multi-step agent frameworks.

Technical level: Intermediate. Readers need a working familiarity with LLM agent paradigms (ReAct, Reflexion), tool calling, and basic graph and information-theoretic concepts (nodes, edges, conditional entropy), but the paper's framing is largely conceptual.

Scope in one sentence: The paper introduces AutoTool, a training-free, graph-based framework that exploits predictable sequential patterns in tool usage ("tool usage inertia") to bypass LLM inference for a portion of tool-selection and parameter-filling decisions.

What This Paper Is About

Current LLM agent frameworks such as ReAct invoke the LLM at every step to decide which tool to use and how to fill in its arguments, which is expensive in tokens and latency. The authors observe that tool invocations are not independent random events but follow highly predictable sequences, and they build a directed graph from historical agent trajectories that captures these sequences and the data flowing between tool parameters. The goal is to serve many of those decisions from the graph instead of from the LLM, preserving task performance while cutting inference cost.

Key Contributions

1. Empirical identification of tool usage inertia. The authors analyze ReAct agent behavior in ScienceWorld, generating 322 trajectories and 6014 tool invocations, and show that tool selection follows low-entropy sequential patterns, both for choosing the next tool and for sourcing its parameters.

2. The Tool Inertia Graph (TIG). A dynamic directed graph, denoted G_t = (V_t, E_t, W_t), built incrementally from execution trajectories. It uses hierarchical Tool Nodes with embedded Parameter Nodes, Tool Sequence Edges for sequential dependencies, and Parameter Dependency Edges for data flow between tools.

3. A graph-based selection algorithm. A two-stage inertial decision process: tool selection via a Comprehensive Inertia Potential Score (CIPS) combining a frequency score and a contextual score, followed by hierarchical, non-LLM parameter filling (dependency backtracking, then environmental state matching, then heuristic filling).

4. Extensive evaluation across three benchmarks. Experiments on AlfWorld, ScienceWorld, and ToolQuery-Academic with ReAct and Reflexion backbones showing reported reductions of up to 30% in inference cost with comparable progress rates.

Main Findings

• Sequential entropy drops sharply with order. Modeling the ScienceWorld action sequence as a k-th order Markov chain, the baseline 0-order entropy of 3.50 bits falls to 2.52 bits for a 1st-order model and 1.93 bits for a 2nd-order model. Likelihood ratio tests confirm both order increases are significant: G²(361) = 9390.70 and G²(3914) = 5437.03 respectively, with p < .001 for both (N = 6014).

• Successor distributions are highly skewed. The go_to action is followed by look_around in 88.7% of cases. After the sequence focus_on → wait, the next action is look_around with probability 55.7%.

• Parameter sources are concentrated. For the use(target) action, the top source (move / source) accounts for 44.8% of parameters, pick_up / OBJ for 22.1%, move / target for 11.5%, pour / OBJ for 11.0%, and Other for 10.6%. For pick_up(OBJ), focus_on / OBJ accounts for 40.1%, move / source 24.3%, pour / from 16.4%, look_at / OBJ 5.9%, and Other 13.3%.

• Reported efficiency gains. On average across datasets, AutoTool reduces LLM call count by 15% to 25% and total token consumption by 10% to 40%.

• ReAct + AutoTool results (AlfWorld). Progress rate rises from 0.394 to 0.531, tokens-in drop from 6560 to 4110, tokens-out from 2310 to 804, and LLM calls from 24.1 to 20.4, giving SpeedUp values of 1.60x (tok-in), 2.87x (tok-out), and 1.18x (LLM calls). On ScienceWorld, progress rate goes from 0.716 to 0.708 with SpeedUp of 1.30x / 1.41x / 1.31x. On ToolQuery-Academia, progress rate goes from 0.901 to 0.895 with SpeedUp of 1.15x / 0.92x / 1.20x.

• Reflexion + AutoTool results (AlfWorld). Progress rate moves from 0.481 to 0.453, tokens-in from 6813 to 5130, tokens-out from 2379 to 1976, LLM calls from 30.7 to 23.7, with SpeedUp 1.33x / 1.20x / 1.29x. On ScienceWorld, progress rate is 0.730 to 0.712 with SpeedUp 0.93x / 1.20x / 1.28x. On ToolQuery-Academia, progress rate rises from 0.917 to 0.923 with SpeedUp 1.33x / 1.19x / 1.26x.

• Overhead is small. Contextual relevance computation accounts for only 2.7% ± 1.5% of total task execution time. Non-semantic components (graph construction, graph search, parsing, parameter filling, general action generation) remain on the order of seconds even when LLM inference time for a task exceeds a thousand seconds — for example, 2604.1 seconds of LLM time on AlfWorld with ReAct+AutoTool.

• Model-agnostic behavior. Replication on ScienceWorld with Llama-3.3-70B, Qwen2.5-72B, and DeepSeekV3 (reported in Appendix C) yielded consistent efficiency gains, indicating the method is not dependent on a specific model.

• Sensitivity behavior. On ScienceWorld with ReAct+AutoTool, a lower inertia threshold θ_inertial (e.g., 0.1) most effectively reduces average LLM calls (reaching the lowest value of 16.85 among tested combinations when α = 0.5), while progress rate remains stable. Even at θ_inertial = 0.2, the number of triggered inertia calls approaches or reaches the 30% ceiling.

• Comparison with related methods. Table 1 positions AutoTool against DFSDT, AnyTool, ToolChain, ToolNet, ToolPlanner, and LLMCompiler across five features (Efficiency, LLM Offloading, Inertia Aware, Parameter Flow, Tool Graph); AutoTool is the only method marked as satisfying all listed features, and the only one with LLM Offloading, Inertia Aware, and Parameter Flow.

Methodology in Plain English

The authors start from a measurement: they run a ReAct agent in ScienceWorld, collect 322 trajectories and 6014 tool invocations, and confirm statistically that the next tool is highly predictable from the recent ones.

From there, they build a graph out of past executions. Each tool is a node; each directed edge between tools records how often one tool follows another. Inside each tool node sits a smaller subgraph of that tool's input and output parameters, with edges recording when one tool's parameter value came from an earlier tool's parameter. Edges carry weights that go up when a sequence leads to success and down when it leads to failure, so the graph tracks effectiveness, not just frequency.

At each decision step, the agent first tries an "inertial call" instead of immediately invoking the LLM. It looks at the last k tools executed (the inertia window, typically set to 2), finds matching historical paths in the graph, and scores each candidate next tool with a Comprehensive Inertia Potential Score: CIPS = (1 − α) · Score_freq + α · Score_ctx, where the frequency score comes from TIG edge weights and the contextual score measures semantic alignment between the agent's current intuition and the tool description (computed with SimCSE).

If the best candidate's score exceeds a threshold θ_inertial, the system tries to fill the tool's parameters using a strict priority order — first backtracking parameter dependency edges to a preceding tool's output, then matching against environmental state, then heuristic filling from the agent's state or task goal. The tool executes without an LLM call only if every required parameter is successfully populated. Otherwise, everything falls back to normal LLM inference.

Two safeguards constrain how often this shortcut is taken: inertia calls may not exceed 30% of total operations, and consecutive inertia calls are prohibited. For ReAct, the authors also add a fault-tolerance recovery path that triggers a check operation after consecutive tool failures; Reflexion+AutoTool omits this to avoid conflicting with Reflexion's own reflection mechanism.

Evaluation uses progress rate (PR) from the AgentBoard framework for accuracy, and average LLM calls plus token consumption for efficiency. All experiments use a pure cold-start setting where the graph is built online from scratch with no prior trajectories. Experiments ran on four Intel Xeon Gold 5117 CPUs and four NVIDIA Tesla V100-SXM2-32GB GPUs, using Llama4-Scout-17b as the default model with sampling temperature 0. Hyperparameters were set to θ_inertial = 0.1 and α = 0.5, tuned to achieve a 10–30% reduction in LLM calls.

Why This Matters

Impact on research. The paper reframes tool selection as a statistical-structure problem rather than a pure reasoning problem, arguing that applying a resource-intensive LLM to highly patterned, low-entropy decisions is over-utilization. It is training-free and modular, so it can be layered onto existing agent frameworks rather than replacing them, and it introduces measurable phenomena (tool usage inertia, parameter flow concentration) that other researchers can build on.

Real-world applications.

• Software development agents that repeatedly chain similar tool calls across code editing, testing, and debugging steps.
• Intelligent personal assistants that run long sessions under latency and cost constraints.
• Scientific research automation, where procedures follow logical sequences similar to the ScienceWorld setting studied here.
• Multi-step API orchestration, such as structured queries against academic or enterprise databases (the ToolQuery-Academic benchmark).

Industry relevance. LLM API cost and latency are the primary runtime bottleneck for deployed agents, so a method that reports 15–25% fewer LLM calls and 10–40% lower token consumption without a commensurate task-performance loss has direct cost implications. The negligible overhead (contextual relevance at 2.7% ± 1.5% of task time) matters for real-time or resource-constrained deployments, and the cold-start setting means adopters do not need pre-collected trajectories to begin.

Future Directions

• A dynamic inertia window. The paper sets the window to 2 by default, noting that a length of 1 loses contextual information while 3 or more sharply reduces the number of matching historical paths on current datasets, hurting generalization and risking overfitting to specific long sequences. Exploring a dynamically changing window is explicitly named as a direction for further optimization.

• Addressing the stated limitations. The conclusion defers the framework's current limitations to Appendix G, which is not included in the truncated content supplied, so the specific limitations are not reported here.

• Extending beyond the evaluated domains. The three benchmarks cover embodied household tasks, procedural scientific experiments, and structured API queries. Whether the inertia assumption holds in less repetitive domains with lower sequential regularity is not reported.

• Sharper separation of inertia from reasoning. The 30% cap and the prohibition on consecutive inertia calls are uniform constraints applied to maximize task progress; how much further efficiency could be extracted with adaptive, task-aware limits is an open question the sensitivity analysis gestures toward but does not resolve.

Target Audience

Researchers and graduate students working on LLM agents, tool use, and inference efficiency will get the most from this paper, particularly those interested in hybrid approaches that combine statistical structure with LLM reasoning. Practitioners building or operating agent systems with real latency and API-cost budgets will find the efficiency numbers and the drop-in integration design directly actionable. Readers without a background in LLM agent frameworks such as ReAct and Reflexion will need to consult the cited background work first.

Authors’ abstract

Large Language Model (LLM) agents have emerged as powerful tools for automating complex tasks by leveraging the reasoning and decision-making abilities of LLMs. However, a major bottleneck in current agent frameworks lies in the high inference cost of tool selection, especially in approaches like ReAct that repeatedly invoke the LLM to determine which tool to use at each step. In this work, we propose AutoTool, a novel graph-based framework that bypasses repeated LLM inference by exploiting a key empirical observation: tool usage inertia - the tendency of tool invocations to follow predictable sequential patterns. AutoTool constructs a directed graph from historical agent trajectories, where nodes represent tools and edges capture transition probabilities, effectively modeling the inertia in tool selection. It further integrates parameter-level information to refine tool input generation. By traversing this structured representation, AutoTool efficiently selects tools and their parameters with minimal reliance on LLM inference. Extensive experiments across diverse agent tasks demonstrate that AutoTool reduces inference costs by up to 30% while maintaining competitive task completion rates, offering a practical and scalable enhancement for inference-heavy frameworks. Our work highlights the promise of integrating statistical structure into LLM agent design for greater efficiency without sacrificing performance.