Skip to content

AutoTool: Efficient Tool Selection for Large Language Model Agents

🕒 Published (v1): 2025-11-18 16:41 UTC · Source: Arxiv · Venue: AAAI 2026 · link

Ask a follow-up

Open an assistant pre-loaded with this paper's context.

💬 Ask ChatGPT✦ Ask Claude

TL;DR

AutoTool introduces a graph-based pre-filter that intercepts each tool-selection step in LLM agents and bypasses LLM inference when historical trajectories predict the next tool with high confidence. It exploits empirically validated "tool usage inertia"—sequential tool transitions follow low-entropy, Markovian patterns—to reduce LLM call counts by 15–25% and token consumption by 10–40% with negligible accuracy loss.

Problem

Frameworks like ReAct invoke a full LLM inference at every action step to determine which tool to call, even when many such decisions are repetitive and predictable. This creates unnecessary computational overhead in multi-step agentic tasks where not all decision points require the LLM's full reasoning capacity.

Method

AutoTool constructs a Tool Inertia Graph (TIG) \(G_t = (V_t, E_t, W_t)\) online from execution trajectories. Nodes are hierarchical: primary Tool Nodes \(v_i\) each contain sub-graphs of Parameter Nodes \(p_i\); edges are either Tool Sequence Edges (transition frequencies between tools) or Parameter Dependency Edges (data-flow between parameter slots). Edge weights are updated via online efficacy feedback: successful inertial calls reinforce edges, failures penalize them.

Before each LLM call, the Inertia Sensing module computes a Comprehensive Inertia Potential Score:

\[\text{CIPS} = (1 - \alpha) \cdot \text{Score}_{\text{freq}} + \alpha \cdot \text{Score}_{\text{ctx}}\]

where \(\text{Score}_{\text{freq}}\) draws from TIG edge weights and \(\text{Score}_{\text{ctx}}\) is a SimCSE-based semantic similarity between the agent's current thought and the candidate tool description. If \(\text{CIPS}(v^*) > \theta_{\text{inertial}}\), the Parameter Filling module attempts to populate arguments via hierarchical backtracking (dependency edges → environment state → heuristics). Only if all parameters are resolved is the tool executed without LLM involvement; otherwise the system falls back to standard inference.

Two hard constraints prevent runaway inertia: inertial calls are capped at 30% of total operations, and consecutive inertial calls are prohibited.

Key Contributions

  • Empirical identification of tool usage inertia: conditional entropy drops from 3.50 bits (0-order) to 2.52 bits (1st-order) to 1.93 bits (2nd-order) on 6014 tool invocations; significance confirmed via \(G^2\)-tests (\(p < .001\)).
  • The Tool Inertia Graph: a hierarchical, dynamically updated directed graph encoding both tool-sequence transitions and parameter-level data flow.
  • A two-stage graph-search algorithm (CIPS-based tool selection + hierarchical parameter filling) that selectively bypasses LLM inference.
  • Framework-agnostic integration demonstrated on ReAct and Reflexion; model-agnostic validation on Llama4-Scout-17B, Llama-3.3-70B, Qwen2.5-72B, and DeepSeekV3.

Results

  • AlfWorld (ReAct+AutoTool): PR 0.394→0.531; token-in 1.60× speedup; token-out 2.87× speedup; LLM calls 1.18× speedup.
  • ScienceWorld (ReAct+AutoTool): PR 0.716→0.708 (−1.1%); token-in 1.30×; token-out 1.41×; LLM calls 1.31×.
  • ToolQuery-Academic (ReAct+AutoTool): PR 0.901→0.895 (−0.7%); token-in 1.15×; LLM calls 1.20×.
  • Reflexion+AutoTool achieves comparable or better speedups across all datasets with similar PR preservation.
  • Semantic overhead (SimCSE embeddings): \(2.7\% \pm 1.5\%\) of total task execution time.
  • Non-semantic graph operations (search + construction): order-of-seconds even when total LLM inference exceeds 1000 s.

Limitations

  • The 30%-cap and no-consecutive-inertia constraint are manually tuned heuristics that bound the achievable speedup ceiling.
  • Evaluated only on three benchmarks with relatively constrained tool vocabularies; generalizability to open-ended, large-scale API environments (e.g., ToolBench's 16k+ APIs) is discussed but not fully evaluated in the main paper.
  • Cold-start setting means the TIG starts empty; tasks with few steps gain less from inertia since the graph has not yet converged.
  • Inertia modeling assumes up to 2nd-order Markov structure; tasks requiring context-sensitive, non-sequential tool use would violate this assumption.
  • No explicit handling of tool set changes at deployment time (concept drift in the TIG).

Relevance to Harnesses / Meta-Harnesses

AutoTool operates structurally as a meta-layer interceptor around existing agent frameworks: it wraps each action-selection step and decides whether to delegate to the LLM or short-circuit it, exactly the role a meta-harness plays when orchestrating sub-agents or tools. The TIG construction mechanism—building a statistical execution model from trajectory logs—is a concrete pattern for how a harness can accumulate operational knowledge to self-optimize over time. The framework-agnostic design (drop-in for ReAct or Reflexion) illustrates how efficiency-oriented meta-harnesses can be composed orthogonally to task-level agent logic. For researchers building orchestration harnesses, this paper provides both empirical grounding (inertia quantification) and a deployable architecture for reducing the cost of repetitive sub-decisions without rewriting the underlying agents.