← Back to feed

Frontier models can now call individual tools with high accuracy. That turns out not to be the problem. A new survey maps where agent deployments actually break: not at the tool call, but at the coordination layer — the logic governing which tools to call, in what order, how to recover when one fails, and how to maintain coherent state across a chain of ten or more operations.

The paper is “The Evolution of Tool Use in LLM Agents: From Single-Tool Call to Multi-Tool Orchestration” (arxiv.org/abs/2603.22862v2), a field-wide review of recent progress on multi-tool agent architectures.

The Benchmark Gap

Current agent benchmarks are built around individual capability tests. An agent is given a task, a tool, and a context window. It either calls the tool correctly or it doesn’t. On these benchmarks, frontier models score impressively — often above 90% for single-tool tasks.

The survey’s key finding is that this success rate degrades rapidly as chains lengthen. An agent that completes 94% of single-step tool calls will complete roughly 71% of three-step chains (assuming independence, which is a floor — real chains have dependencies that compound failures). At ten steps, the success rate falls below 40%. Real-world software work, enterprise integrations, and agentic coding tasks routinely involve 15 to 50 sequential tool operations.

The field’s progress on single-call accuracy has been rapid. Progress on multi-step coordination has been substantially slower. That asymmetry explains why agents look impressive in demos and unreliable in production.

Six Problem Areas

The survey organizes the coordination challenge into six linked domains:

Runtime planning. Most current agents plan linearly — generating a sequence of tool calls upfront and executing them in order. When an intermediate step fails or returns unexpected results, linear plans break without a recovery mechanism. Graph-style planning, where the agent maintains a dependency tree and can backtrack or branch, handles this better but is harder to implement reliably and not yet standard.

Training data and fine-tuning. Multi-step coordination requires training data that reflects complete task trajectories, not isolated tool calls. Current datasets are sparse on long-horizon trajectories with realistic failures and recoveries. Models trained primarily on single-call examples show brittle generalization to chained settings.

Safety. Tool chains create compounded authorization and scope problems. A sequence of read, compute, and write operations may collectively perform an action no individual step would trigger a safety review for. The survey notes that existing safety evals largely test single-call boundary adherence and do not cover emergent behaviors across chains.

Efficiency. Long tool chains accumulate context. Current architectures often pass full history through each step, leading to latency and cost profiles that don’t scale. Selective context compression — retaining only relevant state across tool boundaries — is an active research area with no settled best practice.

Missing tool handling. Agents regularly encounter tasks that require tools not available in their current configuration. Most current agents either hallucinate tool calls or fail ungracefully. Robust degradation — decomposing the task differently when a tool is absent — is not standard behavior.

Benchmarks. Evaluation has not kept pace with deployment complexity. The survey calls for benchmarks that require sustained coordination across 10-50 tool steps, with realistic failure injection, state corruption, and missing-tool scenarios. Most current evals, including SWE-bench and Terminal-Bench, test important capabilities but do not stress the coordination layer directly.

Why This Matters Now

Every major agent product launched in the past six months — AWS AgentCore, Claude Managed Agents, OpenAI Codex Desktop, Perplexity Personal Computer — runs on tool chains. The reliability claims in their launch announcements are generally based on single-task or narrow-domain evals.

The survey’s framework suggests a clear ranking of what to improve first: graph-style runtime planning and rollback have the largest marginal impact on multi-step success rates. Training data quality for long-horizon trajectories is second. Safety and efficiency improvements matter but are less binding at current deployment scales.

For teams building agent workflows on top of frontier models, the practical takeaway is architectural: don’t assume a model that performs well on a 3-step demo will perform well on a 15-step production workflow. The coordination layer is not a property of the underlying model — it’s something you build.