AutoTool: Letting LLM Agents Trade Deliberate Reasoning for Learned Tool Habits

Forum topic · QianXun · 2025-11-19

Summary

AutoTool, a 2025 study by Jingyi Jia and Qinbin Li of Huazhong University of Science and Technology (arXiv:2511.14650), reduces the inference cost of LLM agents by exploiting a discovered "tool usage inertia." Analyzing 322 ReAct trajectories with 6,014 tool calls in ScienceWorld, the authors show tool sequences are highly predictable: conditional entropy drops from 3.50 bits to 1.93 bits with a second-order Markov model, and parameter sources are similarly concentrated. AutoTool encodes these patterns in a dynamically updated Tool Inertia Graph (TIG) with tool and parameter nodes, sequence and dependency edges, and reward-style weight updates. Before each LLM call, a Combined Inertial Potential Score (CIPS) blending edge-frequency and contextual semantic similarity decides whether to bypass the LLM; hierarchical parameter filling (dependency backtracking, environment-state matching, heuristics) completes the call, with graceful fallback to standard LLM reasoning. On AlfWorld, ScienceWorld, and ToolQuery-Academic benchmarks, AutoTool cuts LLM calls by roughly 18-31% and tokens by up to ~2.9x (output) while maintaining or improving task success, and generalizes across Llama, Qwen2.5-72B, and DeepSeekV3. Limitations include data dependence, cold start, and hyperparameter tuning. Code: https://github.com/jiajingyyyyyy/AutoTool.

AutoTool: Efficient Tool Selection for LLM Agents via Tool Usage Inertia

> "The essence of intelligence may not lie in making a perfect choice every time, but in knowing when to trust habit and when to deliberate." > — Jingyi Jia & Qinbin Li, 2025

Source: Jia, J., & Li, Q. (2025). *AutoTool: Efficient Tool Selection for Large Language Model Agents*. arXiv:2511.14650v1. Code: https://github.com/jiajingyyyyyy/AutoTool

The Problem: Every Step Costs a Full LLM Call

Frameworks like ReAct (Yao et al., 2023) drive LLM agents through a reasoning-acting-observing loop, but each step triggers a full LLM inference to decide "which tool next?" — expensive for multi-step tasks. The authors argue that many tool choices occur in highly repetitive, patterned contexts where full reasoning is unnecessary: a statistical method could replace much of it.

Observation: Tool Usage Is Predictable

In the ScienceWorld simulator, ReAct agents produced 322 trajectories with 6,014 tool calls. Key findings:

After go to, 88.7% of next calls were look around; after focus on → wait, 55.7% were look around.
For use(target), 44.8% of parameters came from a move source; for pick up(OBJ), 40.1% came from focus on OBJ.
Modeling tool sequences as a k-order Markov chain, conditional entropy fell from 3.50 bits (order 0) to 2.52 bits (order 1) to 1.93 bits (order 2); likelihood-ratio tests confirmed significance at each step (p < .001).
On ToolBench's macro analysis (1,595 tools), the theoretical max entropy of 10.64 bits contrasted with an observed conditional entropy of just 3.62 bits — a 66% reduction.

The AutoTool Framework

AutoTool builds a Tool Inertia Graph (TIG) — a directed graph G_t = (V_t, E_t, W_t) grown from experience, requiring no training:

Nodes: tool nodes (with nested parameter nodes storing function descriptions and I/O state).
Edges: tool-sequence edges ("tool A often follows tool B") and parameter-dependency edges (data flow).
Weights update via reward-style feedback: w_{t+1}(s_i, s_j) = w_t(s_i, s_j) + Δw_success / − Δw_failure — analogous to the cognitive habit loop (cue → routine → reward).

Decision Procedure

1. Inertial Sensing: before each LLM call, the system checks the last k tools (the inertia window, k = 2 in experiments) against the TIG. Candidate tools receive a Combined Inertial Potential Score: CIPS = (1−α)·Score_freq + α·Score_ctx (α = 0.5 default), where Score_freq reflects edge-weight reliability and Score_ctx measures semantic similarity to the current context. Inertial invocation fires only if the top CIPS exceeds θ_inertial (0.1). 2. Hierarchical Parameter Filling: (a) dependency backtracking along parameter edges, (b) environment-state matching, (c) heuristic filling from the task goal. If any required parameter cannot be filled, the system falls back to standard LLM reasoning.

Safety valves: an inertial-call ceiling of 30% and a ban on consecutive inertial calls ensure the LLM can correct course.

Experimental Results

Evaluated on AlfWorld (household tasks), ScienceWorld (scientific procedures), and ToolQuery-Academic (structured API queries):

ReAct + AutoTool

AlfWorld: 1.18x fewer LLM calls; 1.60x fewer input tokens and 2.87x fewer output tokens; progress rate up from 0.394 to 0.531 (aided by a fault-tolerance mechanism that triggers checks on repeated failures).
ScienceWorld: 1.30x / 1.41x token reductions, 1.31x fewer LLM calls.
ToolQuery-Academic: 1.20x fewer LLM calls, near-parity output tokens (0.92x).

Reflexion + AutoTool: smaller call reductions (1.26–1.29x) but stable progress rates, thanks to higher-quality inertia trajectories.

Cross-model robustness (ScienceWorld): Llama-4-Scout-17B (−23% tokens-in), Llama-3.3-70B (−29%), Qwen2.5-72B (−18%), DeepSeekV3 (−35% tokens-in, −31% calls, progress rate up from 0.448 to 0.589). DeepSeekV3's gain stems from AutoTool's preconfigured recovery paths that mitigate its weaker instruction following.

Online learning: after a cold-start of roughly 40 tasks, performance rises steadily and later matches baselines while efficiency gaps widen.

Parameter filling success rates: Academic 76.92% (dependency-graph mode), ScienceWorld 51.24%, AlfWorld 27.88% — reflecting the ambiguity of open-ended natural-language environments versus structured APIs.

Case Studies and Failure Modes

Success: routine sequences (look around, go to kitchen) are taken over by inertial calls, conserving LLM effort.

Documented failures (Appendix D) include: parameter mismatch (placing a CD in a drawer when the goal was a safe, ignoring physical reachability), redundant actions (navigating to a location already occupied), and object-semantic overgeneralization (attempting to open a sink basin, which has no lid). These motivated the dual safeguards (30% ceiling; no consecutive inertial calls).

Limitations and Future Work

Dependence on historical data quality/quantity; cold start in very large tool sets.
Degraded inertial prediction in highly dynamic or reasoning-heavy tasks.
Parsing overhead for unstructured tool outputs; manual tuning of θ_inertial and α.

Future directions include adaptive hyperparameters, richer semantic context, hierarchical (abstract-to-concrete) inertia graphs, and cross-task TIG transfer.

Key Takeaways

Tool invocation sequences in LLM agents are low-entropy and highly predictable — a formal, information-theoretic finding.
A training-free, graph-based habit mechanism can cut LLM calls by ~20–30% and tokens substantially without sacrificing, and sometimes improving, task success.
The paradigm shift is from purely reactive reasoning (ReAct) toward a hybrid that knows when to trust habit and when to deliberate — with graceful fallback as the reliability guarantee.

Funding: National Natural Science Foundation of China (Grant No. 62502174).