acceptodds
Under review as a conference paper at ICLR 2027

EvoToolAgent: Co-Evolving Autonomous Tool Agents and Interaction for Robust LLM Tool Use

Abstract

Large language model (LLM) agents increasingly rely on external tools to perform complex tasks. However, tool interfaces, output formats, and availability may continuously change during deployment, making it difficult for agents designed for static tool environments to adapt reliably. We argue that the key to dynamic tool adaptation lies not only in recovering from failed tool calls, but also in identifying the sources of failure and directing failure feedback to the appropriate system components. To this end, we propose EvoToolAgent, an attribution-driven framework for agentic system evolution in dynamic tool environments. EvoToolAgent performs component-level failure attribution to localize errors arising during task execution to specific system components, thereby providing a unified mechanism for both within-task local recovery and cross-task system evolution. In addition, we introduce EvoToolBench-D, a benchmark designed to systematically evaluate the adaptability of agents to tool changes and failures. Experimental results demonstrate that EvoToolAgent consistently outperforms baselines across different backbone models and dynamic tool conditions, highlighting the importance of explicit failure diagnosis and structured recovery for tool-using agents in dynamic environments.

Primary area:
foundation or frontier models, including LLMs
Keywords:
LLM agents, multi-agent systems, self-evolution

Reviews

Among:
Shape:
1234this paper, Bottom 10%
Figure 1. Mean review rating of the reviewed papers at ICLR 2027. This paper averages 1.67 over 3 reviews, above 10% of the others.
Reviewer_9CeZOpenReview ↗
Rating
2
Confidence
3
Informativeness
2
Presentation
2
Soundness
1
Read review
Paper summary

The paper studies how tool-using agents handle changes in tool interfaces, outputs, and availability. EvoToolAgent links failures to system components and uses this diagnosis for local recovery and offline evolution. The paper also introduces EvoToolBench-D, a benchmark with controlled tool changes. Experiments test online adaptation across three backbones and separately evaluate a fixed configuration chosen through offline evolution.

Critical strengths
  1. The experiments use matched execution budgets and three random seeds, with gains across three backbones.
Critical weaknesses
  1. Table 3 removes the whole Recovery Loop, including repair and partial replanning. It shows that recovery helps, but not whether component-level attribution helps more than a simpler repair policy with the same actions and budget. This leaves the main contribution insufficiently tested.
  2. The benefit of co-evolution is unclear. Population evolution is disabled in the main comparisons, including for baselines built around evolution. Table 4 compares only the evolved configuration’s development and frozen-test results. A small gap does not show that evolution helped. The paper needs a comparison with the initial configuration and another search method under matched budgets and test rules.
Questions for authors
  1. Do you have results that keep the repair actions, evidence preservation, and execution budget fixed, but replace component-level attribution with a generic repair policy?
  2. Under Protocol B, how does the evolved system compare with the initial configuration and untargeted evolution? Can you compare them using the same search budget and frozen-test rules?
Reviewer_6A6aOpenReview ↗
Rating
1
Confidence
2
Informativeness
2
Presentation
2
Soundness
1
Read review
Paper summary

EvoToolAgent addresses tool-use failures in dynamic environments. It wraps tools as Tool Agents and combines bounded local repair, component-level attribution, reflective memory, interaction-graph updates, and offline population evolution. The paper also introduces EvoToolBench-D, a benchmark covering QA, API invocation, multi-tool workflows, and code repair under several controlled tool perturbations.

The bundled EvoToolAgent system reports the highest scores among the listed methods under Protocol A. That protocol, however, disables global evolution. Protocol B performs offline evolution and then evaluates the selected configuration with cross-task updates frozen and within-task self-refinement retained, without a matched baseline comparison.

Critical strengths

I like the problem addressed by the paper. Dynamic tool failures can arise from parameter construction, execution, routing, planning, or result use. The distinction between local repair and broader system recovery is useful, and the proposed evidence preservation and dependency-scoped replanning mechanisms are clearly described.

The paper also provides useful implementation detail, including shared retrieval and execution budgets, multiple Protocol A seeds, controlled perturbations, and a common set of local tool categories.

Critical weaknesses

My main concern is that the central co-evolution claim is not tested by the main comparison. Protocol A disables global evolution, so the evolution-named methods are only fixed diagnostic variants. Protocol B runs evolution but provides neither matched baselines nor a generation-zero control. The experiments therefore support the local recovery system, not the claimed benefit of attribution-guided co-evolution.

The attribution and benchmark evidence is also weak. Attribution is implemented as an ordered rule hierarchy, but its accuracy is never evaluated and its component boundaries are ambiguous. The benchmark lacks item-level validation and contamination statistics, and the full system uses a more prescriptive evidence-locked synthesis procedure than the baselines without a matched ablation. These factors make the source of the reported gain unclear.

Questions for authors

Can the authors provide compute-matched Protocol B baselines and a generation-zero control?

What are the benchmark’s item-level validation, deduplication, and contamination statistics?

What is the accuracy of component attribution, and does it still help under a synthesis-matched ablation?

Reviewer_A8YnOpenReview ↗
Rating
2
Confidence
3
Informativeness
2
Presentation
3
Soundness
2
Read review
Paper summary

This paper studies tool-using LLM agents in dynamic environments, where tool interfaces, output formats, and availability change during deployment. The authors argue that adapting to such changes requires not only recovering from failed calls but also identifying the source of each failure and directing feedback to the right component. They propose EvoToolAgent, a multi-agent framework where each tool is wrapped as an autonomous Tool Agent with input adaptation, result validation, and local repair policies, coordinated by a Task Agent through an explicit interaction graph. A hybrid failure detector and an attribution module assign each failure to one of four components, namely planning, tool execution, routing, and result use. The attribution then drives minimal-scope recovery within a task and targeted mutation of the corresponding component during offline evolution. The authors also build EvoToolBench-D, an 800-task benchmark with six perturbation types over nine local tools, converted from ToolQA, API-Bank, and ToolBench plus synthetic tasks. Under a shared test-time budget, EvoToolAgent outperforms 13 baselines on accuracy and recovery across three backbones, and a frozen evolved configuration transfers to held-out tasks with a small fitness gap.

Critical strengths
  1. The problem is practical and the attribution-driven framing is sensible. Connecting component-level failure attribution to both within-task recovery and cross-task evolution gives a unified story, and the formalization in Appendix D is precise enough to reimplement.
  2. The evaluation design is careful in several respects. The two protocols cleanly separate test-time adaptation from offline evolution, all methods share the planner, budget, and initial configuration, and the benchmark logs execution-level signals beyond final accuracy. The appendices are also unusually honest about the benchmark construction limits.
Critical weaknesses
  1. The central mechanism is never evaluated directly. Attribution accuracy is not measured against the failure-type annotations that the benchmark already records, so it is hard to tell whether the gains come from correct attribution or simply from more repair attempts and memory use.
  2. Some results are hard to interpret. EvoToolAgent shows zero variance across seeds while baselines vary by more than ten points, removing the RecoveryLoop raises Exec. ETS by 19 points without explanation, and several evolution-named baselines under Protocol A are fixed-configuration variants with nearly identical scores, which reduces the effective diversity of the comparison.
Questions for authors
  1. Can you report the agreement between the attributed component and the annotated failure type in EvoToolBench-D, to show that the attribution step works as intended?
  2. Why does the proposed system have zero variance across the three seeds while Reflexion and StaticToolAgent vary by over ten points, and why does removing the RecoveryLoop increase Exec. ETS from 71.9 to 90.9?
  3. What is the per-task cost in LLM calls and tokens of EvoToolAgent compared with ReAct under the shared budget, and how were the AI-generated synthetic tasks verified before inclusion?

From OpenReview, CC BY 4.0. Authors as signed there; shown unedited.

Related papers

Loading the map…

Discussion (0)

Sign in to comment.