ToolTree: Efficient LLM Tool Planning via Dual-Feedback Monte Carlo Tree Search and Bidirectional Pruning
Authors: Shuo Yang
Caren Han
Yihao Ding
Shuhe Wang
Eduard Hovy
Venue: ICLR 2026 Poster (2026)
Keywords: Tool Planning
Monte-Carlo Tree Search
Agent Tool Use
Primary area: applications to computer vision, audio, language, and other modalities
TL;DR: We provide a novel tool planning method for LLM agent handling the error propagation and inter-dependency problem in agent tool use

Abstract: Large Language Model (LLM) agents are increasingly applied to complex, multi-step tasks that require interaction with diverse external tools across various domains. However, current LLM agent tool planning methods typically rely on greedy, reactive tool selection strategies that lack foresight and fail to account for inter-tool dependencies.
In this paper, we present ToolTree, a novel Monte-Carlo tree search-inspired planning paradigm for tool planning. ToolTree explores possible tool usage trajectories using a dual-stage LLM evaluation and bidirectional pruning mechanism that enables the agent to make informed, adaptive decisions over extended tool-use sequences while pruning less promising branches before and after the tool execution. Empirical evaluations across both open-set and closed-set tool planning tasks on 4 benchmarks demonstrate that ToolTree consistently improves performance while keeping the highest efficiency, achieving an average gain of around 10\% compared to the state-of-the-art planning paradigm.

Published as a conference paper at ICLR 2026
TOOLTREE: EFFICIENT LLM AGENT TOOL PLANNING VIA DUAL-FEEDBACK MONTE CARLO TREE SEARCH AND BIDIRECTIONAL PRUNING
Shuo Yang', Soyeon Caren Han'; Yihao Ding², Shuhe Wang', Eduard Hovy!
School of Computing and Information Systems, The University of Melbourne School of Physics, Mathematics and Computing, The University of Western Australia shuo yang- 30 funnmmelbb edu.au
ABSTRACT
Large Language Model (LLM) agents are increasingly applied to complex, multi- step tasks that require interaction with diverse external tools across various do- mains. However, current LLM agent tool planning methods typically rely on greedy, reactive tool selection strategies that lack foresight and fail to account for inter-tool dependencies. this paper, we present ToolTree, a novel Monte Carlo tree search-inspired planning paradigm for tool planning. ToolTree explores possible tool usage trajectories using a dual-stage LLM evaluation and bidirec- tional pruning mechanism that enables the agent to make informed, adaptive de- cisions over extended tool-use sequences while pruning less promising branches before and after the tool execution. Empirical evaluations across both open-set and closed-set tool planning tasks on 4 benchmarks demonstrate that ToolTree consis- tently improves performance while keeping the highest efficiency, achieving an average gain of around 10% compared to the state-of-the-art planning paradigm.
INTRODUCTION
Recent advancements in Large Language Models (LLMs) (Brown al. 2020 Ouyang al. 2022
Touvron et al. 2023) have propelled the emergence of language agents capable of tackling complex multi-step tasks across various domains, including software engineering (Yang et al. [2044) web browsing (Zhou et al. (2023), scientific discovery (Bran et al. (202)) and multimodal understanding (Wu et al. 2023). critical aspect of enabling these agents to solve sophisticated problems lies in their ability to plan and coordinate external tools (Qu et al. (025). Effective tool planning leverages the prior knowledge of LLMs by decomposing complex tasks, reasoning about which tools are appropriate, and generating structured plans that assign intermediate steps to these tools. In doing so, LLMS can integrate external functionalities into their reasoning process, thereby enhancing their
effectiveness in completing complex tasks (Schick et al. 2023 Li et al., 2024 Lu et al. 2025).
To enhance the tool planning capabilities of LLMs, existing research has primarily followed two directions. The first is greedy-based tool planning, where the model independently selects and exe- cutes the tool that appears most suitable at each step, without engaging in long-term rewards. (Weil et al.) 2022 Shen et al.) 2023 Yao al.) 2023b Lu et al. 2025 Liu et al. (025).. As result, these approaches often suffer from brittle performance, particularly when early suboptimal choices propagate errors that compound irreversibly and compromise later steps. Besides, these methods also tend to waste computation by following only single trajectory with no exploration of alter- natives. On the other hand, search-based methods attempt to address this limitation by expanding multiple candidate branches, but they introduce new challenges when tools are involved (Yao et al., 2023a Zhuang et al., 2024 Zhou et al. 2024). The branching factor grows exponentially with tool types, arguments, and evolving states, leading to high costs and unpredictable latency. Moreover, many variants evaluate hypothetical thoughts rather than executed actions, so ranking is decoupled from actual tool use utility, and improvements realized several steps later are rarely credited back to
Sooeon Caren Han is the corresponding author

---

Published as a conference paper at ICLR 2026
How mony wheels there totaf?
Greedy-based
Search-based
Tool
Tool A
Tool
113
Pre-pruning
Tool 8
Tool B
Tool C
Tool
Tool
Tool
Tool
Tool C
Tool
Tool
Post-pruning
10
18 wheels
20 wheels
Comparison of ToolTree with greedy search and search-based tool planning. Our ToolTree chooses the optimal tool trajectory and answers correctly with 20.
Figure 1:
earlier decisions. Together, these drawbacks highlight the need for planning approach that is both forward-looking and outcome- grounddd, while remaining compute-efficient under fixed budgets.
Our ToolTree tackles the above two issues at the same time. ToolTree frames tool planning search problem guided jointly by fast pre-execution prior and a grounded post-execution utility, enabling agents to allocate computation adaptively and recover from early missteps without task- specific retraining as illustrated in Figure [ Our design integrates pre-execution scoring into the selection policy
predict the utility of tool before it is invoked, while post-execution score assesses its actual contribution based on observed outcomes as rollout rewards, and applies comple- mentary pre- and post-pruning eliminate unpromising branches. This feedback loop enables the agent to refine its strategy iteratively, incorporating foresight and hindsight into tool selection. To evaluate the effectiveness ToolTree in enhancing LLM agent tool planning abilities, we compare ToolTree with greedy and search- based planning methods on four tool use benchmarks spanning both closed-set and open-set tool scenarios, with around 10 percent improvement over baseline, achieving SoTA performance with 66.95 Fl score on GTA and a 69.04 pass rate on ToolBench.
Overall, our contributions can be summarized follows:
We present ToolTree, novel Monte Carlo tree search-inspired planning paradigm that frames I.LM agent tool use as search guided by pre-execution priors and post-execution rewards, enabling robust multi-step reasoning without retraining.
ToolTree effectively integrates a dual-evaluation guided tree traversal method with bidi- rectional pruning, which integrates pre- and post-scoring into search and eliminates weak branches, improving accuracy per unit compute under fixed budgets.
We evaluate ToolTree on four benchmarks of both closed-set and open-set tool planning, demonstrating its superior effectiveness and efficiency. The improvements scale consis- tently with the number tool sets, model size and computing resources.
PRELIMINARIES
In this section, we introduce the preliminaries of the tool planning task for language agents, includ- ing (1) the formal problem definition for tool planning: (2) tree-search enhanced tool planning; and (3) the fundamentals of Monte Carlo Tree Search (MCTS).
Problem Definition: Tool Planning. Tool planning is the task that decides not only which tools a language model should use, but also when and what order to use them, order to accomplish task both efficiently and accurately. Unlike simple tool selection, which focuses the most appropriate tool at a single step, tool planning requires reasoning over entire sequences of tools, with the objective of discovering optimal sequence that maximizes task success.
identifying
Formally, let (1) Tin = tt.,t2...., .,,} denote a set of available tools. Each tool E Tib is represented by structured tool card C, with explanatory metadata using JSON format provide
2

---

Published as a conference paper at ICLR 2026
standardized information for further utilization, which can be found in Appendix [.3 (2) S be the state space, where each state 8 E S encodes the current dialogue context and any accumulated intermediate results; (3) A denote the action space, where each action corresponds to invoking tool 4, E Ti with an input; and (4) R S - IR he a reward function that measures how correct, informative efficient the current tool sequence is. Then, the tool planning task is to learn search for a policy x S + A that generates sequence of actions s* = {a1, 02,,..,, anJ. where a, E A to maximize the expected reward: π = arg max [B[[(s)) |T, Tib]
Tree Search-enhanced planning, Tree-search enhanced tool planning reframes the above tool planning task as a search problem: The agent explicitly constructs and evaluates candidate sequences of tool invocations (sequences) and uses a specific search policy to choose actions that are promising in expectation. Specifically, search tree constructed with nodes corresponding to states & E S and edges corresponding to actions E A. Each root-to-node path corresponds to a partial plan where denotes the number of searched child nodes. The tree search procedure estimates terminal rewards R(s") for candidate plans and returns the highest-value plan.
s {a),.... 04)
Monte Carlo Tree Search (MCTS). Monte Carlo Tree Search (MCTS) is a heuristic search al- gorithm for decision-making in large and complex search spaces, most notably applied in game playing (e.g.. Go (Silver et a 2016) and Chess (Helfenstein et al.) 2024 and planning problems (Feng et al., 2023). Basically, the MCTS process can be decomposed into four iterative steps: (1) selection, starting from the root, the algorithm recursively selects child nodes according to a tree policy, such as UCT (Koesis & Szepesvári 2006) and PUCT (Silver al. 2017) that balances ex- ploration and exploitation; (2) expansion, if the selected node is not terminal, one or more child nodes are added the tree, representing possible future actions; (3) simulation, from the expanded node, a policy-guide
simulation is performed to approximate the outcome of completing the plan from that state; (4) back propagation, the result of the simulation propagated back up the tree to update the computed rewards of the traversed nodes. By repeating this procedure many times, MCTS refines its estimates of action values and converges toward high-quality plans.
PROPOSED METHOD: TOOLTREE
In this section, we demonstrate how ToolTree performs tool planning by casting multi-tool use as Monte Carlo Tree Search (MCTS) inspired planning paradigm over executable trajectories in Figure We first outline the overall process in Section 3.1 We then demonstrate the unique design of dual evaluation and pruning in Section 3.2
2
3.1 OVERVIEW
We view tool planning as a sequential decision process where each state encodes the evolving dialog context and intermediate results, and each action corresponds to invoking a candidate tool from the library Tia = [tt.....ttyy }. The objective is to discover a trajectory that maximizes task utility within fixed rollout budget Rmax-
Unlike prior approaches that rely on a separate planner, ToolTree integrates tool selection, execu- tion, evaluation and pruning directly into the MCTS loop. At every step, the search is guided by two complementary signals: a lightweight pre-evaluation that anticipates the usefulness of an action be- fore execution, and post-evaluation that scores the grounded output afterward. This dual feedback supports both exploration and pruning, enabling deliberate, training-free planning that generalizes across diverse tool libraries. The search terminates when the budget met or improvements plateau, and the highest-valued trajectory is returned to generate the final answer. This book-ahead/look-bat loop allows the agent recover from early errors, avoid dead-end tool combinations, and allocate its limited call budget to the most promising trajectories. The overall process is depicted in Figure 2 with Selection, Pre-evaluation, Expansion, Execution, Post-Evvluation, and Backward Propagation.
Selection. Given the current search state s, the search descends the tree by repeatedly selecting the child action that maximizes a prior-augmented UCT score:
In N(s)
UC = a)) + Arpro(s,a)
(1)
as)
3

---

Published as a conference paper at ICLR 2026
Repeated times
LEM
Input
Selection
Pre-Evaluation
Exponsion
Exccution
Post-Evaluation
Book propagetion
Predictor
Answer
irpat
LISS
Inaut
Ipps
Image
Threshold S
Question A
Are
Updatedd
affecte??
Outsut
Figure Architecture overview of ToolTree. An input query is processed sequentially via iterative dual evaluation -iuiddd Monie Carlo Tree Search, including selection, pre-evaluation, expansion, exccution, post-evaluation and buckward-propagatee tool trajectories with the highest reward found by the MCTS to produce the final prediction.
The Answer Predictor then incorporates the
where ((s, a) drives exploitation as it accumulates the post evaluation rewards obtained so far. N(s) and N(s, are visit counts and (s, a) [0, 1] is fast, predictive signal available before executing action a. Only admissible actions a E A(s) where tools with input schema compatible with the current context are considered; ties broken by larger Nss) followed by small random jitter to preserve exploration diversity. The use of (ree a) biases early rollouts toward promising branches while retaining the exploitation pressure from ((s.a).
Expansion. Upon reaching a leaf state = (C,, A1æ), we enumerate the remaining admissible actions Arem (st) A(s;) {aI..... .a). For each candidate score Tpe (st, a) and instantiate new child node (st, a) only if Tpr (s, a) 2 Tpre (pre-pruning, consistent with the prior term in Eq. [.. and the tool's I/O schemas are type-compatible with C-- When tools accept structured arguments, we generate minimal, schema-valid argument draft and cache with the node avoid regenerating at selection time.
(st). we obtain its predictive
Execution. For selected child (st, a). we invoke the corresponding tool/API with its arguments, yielding an output 0++1. The context is updated to Ct-1 by appending (a, oc+1) 1 in structured form. To reduce waste, we employ deterministic caching keyed by (a, args): if an identical call has already been made within the current rollout, its 0++1 reused. Persistent failures attach an error token to 0c+11 downstream compatibility checks and scoring can handle the outcome explicitly.
Backward Propagation. After execution, the resulting post-execution score [po a) E [0, is propagated from the new child back to the root. For every edge (s, a) on this path, we update the ((s,a) Q a) (==((s..)=Q((a)) N(e.0)
counts and value estimate N(ss, a) + N(s, a) + 1, This running average refines the exploitation term in Eq. I allowing subsequent selections to reflect observed utility. We also maintain ((s) < Ea. (ss, for use in the exploration bonus.
3.2 DUAL EVALUATION AND PRUNING
Classical MCTS balances exploration and exploitation but is agnostic to (i) the plausibility of a tool call before execution and (ii) the grounded utility of its realized output afterwards. ToolTree injects two lightweight, training-fre frre signals into the loop: pre-evaluation Tpr((s, a) [0. 1] that forecasts usefulness prior to execution, and post-evaluation rpos (s, a) E [0, 1] that scores the produced out- put. These signals serve complementary roles tros-foresight and hindsight-ann and enable bidirectional pruning that keeps the tree compact without sacrificing solution quality.
Fre-Evaluation. For newly encountered pair (s, a), we query a LLM judge to score Tpre (s, a) based on the current context C, the tool card (I/O schema, domain tags, examples), and a schema- valid argument draft. This score enters selection via the prior-augmented exploration bonus in Eq. and also gates expansion:
A (st) {a E A(st) Tpre (8t, 2 Tpre
(scep(8t) top-K (A+(st) rpre).
4

---

Published as a conference paper at ICLR 2026
Only actions in (st) are expanded. Intuitively, T'e removes obviously incompatible low- yield branches before any tool call, reducing the branching factor while still allowing exploration through the UCT term. Depth-aware annealing of X (or of Tpre) can gradually temper the influence of the prior as empirical evidence accumulates.
cost-Evaluation After executing (st, a) and obtaining 0r+-1, we score grounded utility with the same LLM judge:
ppou( a) = -[Cr. a, 0-11 E [0,
where J evaluates task-consistency (e.g., correctness proxies, relevance, constraint satisfaction) and robustness cues. This score drives exploitation by updating the running mean Q(s, a) in backward propagation and directly supports post-pruning: edges with (St. a)) < Tpost are marked non- expandable to prevent further budget on unproductive continuations. Because Tpost computed on executed actions, it yields faithful credit assignment compared to ranking hypothetical thoughts.
Bidirectional Pruning. Combining both signals yields a two-sided budget control: Pre- Pre-pruning to curbing expansion of low-
discard (x, a) if pre (8, a) < Tpe (or if it falls outside the promise children. Post-pruning while after execution, mark (8t, a) non-expandable reea (8,, a) < Tpost trimming branches disproven by evidence. We also cache (a, args) H to avoid duplicate calls within a rollout; failures attach a typed error token so pruning decisions remain explicit rather than implicit timeouts. Together, these rules concentrate rollouts branches that both likely (per rpre) and useful (per Tpes),, improving perascyo- under fixed R Rimax-
4 EXPERIMENTS
4.1 EXPERIMENT SETUP
We evaluate ToolTree across two complementary regimes that stress different facets of LLM agent tool use: closed-set tool planning with GTA (Wang et al. 2024) and m&m (Ma et al. 2024), where a small, fixed tool set with typed I/O must be composed
short multi-hop chains, and open-set tool planning with ToolBench (Qin et al., 2023) and RestBench (Song et al. (023). where the action space spans dozens of APIs/endpoints and API retrieval part of the problem. These two tasks demonstrate the effectiveness and efficiency of ToolTree.
Datasets. We use four datasets covering two tasks to test our method. For (i) closed-set tool planning we adopt GTA (Wang et al. 2024) and m&m (Ma et al. 2024), each of them provides fixed tool set of size 14/33 with typed I/O and short multi-hop chains. We follow the original setup by evaluating this task in both step-by-step mode and end-to-end modes. For (ii) open-set tool planning we use ToolBench (Qin et al. 2023) and RestBench (Ma et al., (024), which pair 16,464 and 143 real APIs, respectively, with multi-tool retrieval-thee sereevall--e--epeeee then-planning scenarios under judge-based protocol. We follow the initial setup using pass rate and win rate as the evaluation metrics. More details can be found in Appendix B.I and B.2
Baselines. For (i) closed-set tool planning on GTA and m&m we compare our method against: 1) Zero-shot, 2) ReAct (Yo al. (023b), 3) Chain-of-Thoughh (Wei al. 2022), 4) Best-First search (Koh et 2024), 5) Tree-of- Thought Yao et al. (023a), 6) A Search developed in the ToolChain paper (Zuang et al., 2024). and 7) Monte Carlo tree search (Zhou al.) 2024). These baselines span the spectrum from no planning through greedy, reactive planning to search-based planning, providing a comprehensive contrast on small, typed tool suites. For (ii) open-set tool planning on ToolBench and RestBench, we use: 1) Zero-shot, 2) Chain-of-Thoughh 3) ReAct, 4) DFSDT QQn ct al. (202)), and 5) Monte Carlo tree search, emphasizing planning-centric controllers standard for large API spaces, while retaining simple baselines to isolate planning gains. To ensure fair com- parison, all planners share the same tool schemas and descriptions, the same type pre-gating pipeline and the same caching policy for tool outputs and LLM calls. We also enforce identical compute and rollout budgets. These shared engineering settings are applied uniformly across methods to isolate the effect of the planning strategy itself. More details in Appendix B.3
5

---

Published as a conference paper at ICLR 2026
GTA
m&m
Model
Planner
step-by-step
End-to-End
Step bttp-by-teep
Multi-step
AVG
AVG
Tool
Arg
Plan
Exec
Tool
Arg
Plan
Exec
Zero-Shot
58.73
28.44
60.18
33.85
45.30
72.48
67.44
77.48
71.25
ReAct
60.13
29.43
68.26
34.80
48.16
73.55
65.10
82.16
69.42
72.56
CoT
56.10
25.58
66.47
35.63
45.95
70.13
65.27
76.12
66.96
69.62
Best-First
58.42
30.13
69.96
34.46
47.99
74.42
66.83
83.58
68.37
73.80
GPT-4o-mini
ToT
62.41
33.12
72.94
37.42
51.47
75.58
70.84
82.58
71.37
75.59
A*
64.47
35.26
73.86
38.16
52.94
75.16
71.85
84.74
72.59
76.59
LATS
65.88
37.26
74.28
38.24
53.91
76.84
70.16
83.38
72.94
75.83
ToolTree (ours)
67.83
39.64
76.44
55.89
77.25
71.26
85.52
73.58
76.90
Zero-shot
70.16
38.52
77.14
45.28
57.78
78.52
80.17
85.17
78.47
80.58
ReAct
71.42
40.58
75.52
46.33
58.46
83.58
81.24
84.42
76.58
81.46
CoT
66.52
42.17
73.22
42.86
56.69
85.58
77.84
78.16
71.43
78.75
Best-First
72.13
44.26
77.64
47.83
60.46
84.47
82.17
85.84
78.11
82.65
GPT-4o
ToT
72.53
43.68
78.84
46.53
60.40
86.28
83.74
85.26
80.35
83.91
A+
74.29
47.58
79.96
46.26
62.52
87.17
83.44
86.87
81.49
84.74
LATS
77.84
49.90
82.57
48.80
64.78
88.89
84.77
88.38
83.77
86.45
ToolTree (ours)
79.26
50.84
85.53
52.17
66.95
91.92
86.16
90.47
85.88
88.61
Comparison of ToolTree with other baselines across GTA and m&m. The experiment is carried out under both step-by-step and end-to-end mode. "Tool" stands for tool selection Fl score; " "Arg" stands for argument prediction F1 score; "Plan" and "Exec" stand for planning and execution F1 score. Ours achieves the best performance overall.
Table 1:
ReAct
Best-first
TOT
LATS
Ours
Per Derformance vs Slep Limil
Running Time vs Step Limil
Efficiency vs Step Limil
1200
Efficiency (Aperf %. Bsecard)
75
Running Time (seconds)
0.06
Perforannce 1%)
800
0.05
70
600
0.04
0.03
65
0.02
200
60
0.01
50
100
125
25
50
75
100
125
50
100
125
Stop Limit
Stop Limit
Stop Lim
Figure 3: Progressive efficiency analysis across step limits. (a) Performance vs. step limit; (b)
Runtime step limit; (c) Efficiency step limit. ToolTree achieves the highest efficiency compared with baselines. mprovements are largest for step limits between 12 and 64.
4.2 CLOSED-SET TOOL PLANNING ON GTA AND M&M
We compare ToolTree with the selected baselines on GTA and m&m on both step-by-step and end- to-end mode under GPT-4o and GPT-4o-mnni. For step-by-step mode, we measure Tool F1 and Arg Fl to evaluate the tool selection and argument prediction ability. For end-to-end mode, we report F1 score for both planning and execution. GTA and m&m offer typed tool APIs and gold protocols across modes, allowing us cleanly measure both planning and execution quality.
Results. As demonstrated in Table ToolTree attains the best overall average score on both datasets and model backends. On GTA with GPT-4o, it achieves 66.95 average score, outperforming the vanilla MCTS baseline by more than 2.2 points. On m&m with GPT-4o, ToolTree reaches 88.61 average of both modes, outperforming the zero-shot baseline by more than 8 points. The same pattern holds for GPT-4o-mn mini with smaller but consistent margins. Mcanwhile, greedy controllers like Zhro-shot, ReAct and CoT lag behind search-based methods, confirming the value of lookahead

---

Published as a conference paper at ICLR 2026
RestBench-TMDB
RestBench-Spotit
ToolBench
Model
Method
Pass
Win
AVG
Pass
Win
AVG
Pass
Win
AVG
Zero-shot
33.28
50.00
41.64
26.44
50.00
38.22
28.85
50.00
39.42
CoT
34.42
54.70
44.56
29.82
53.10
41.46
26.29
55.47
40.88
ReAct
38.82
61.06
49.94
32.64
59.95
46.30
34.30
58.94
46.62
GPT-4o-mini
DESDT
46.20
64.26
55.23
35.10
65.47
50.28
38.84
68.29
53.57
LATS
51.33
66.67
59.00
39.81
72.85
56.33
40.08
65.77
52.92
Ours
55.17
70.40
62.79
42.08
72.18
57.74
42.24
67.90
55.07
Zero-shot
56.28
50.00
53.14
49.54
50.00
49.77
47.58
50.00
48.79
CoT
58.52
52.32
55,42
47.92
44,55
46.23
46.88
47.57
47.23
ReAct
62.42
66.17
64.30
53.27
60.72
57.00
52.38
63.39
57.89
GPT-4o
DFSDT
66.57
69.08
67.82
55.48
71,63
63.55
54.86
68.59
61.73
LATS
68.26
74.44
71.35
61.25
75. 75.80
68.53
59.25
73.85
66.55
Ours
72.40
75.59
74.50
60.87
78.84
71.36
61.27
76.81
69.04
Table 2: Open-set tool-planning results RestBench and ToolBench using GPT-4o-mini and
GPT-4o as back-end LLMs. Higher values indicate better performance; the best score for each dataset-model pair is highlighted in bold. "Pass" and "Win" refer pass rate and win rate.
even with small typed tool suites. Among the rest baselines, while ToT, A and LATS improve progressively, ToolTree remains top its dual pre-Ipost-evaluation with pruning filters implau- sible actions before expansion and cuts unproductive branches after execution using real feedback, concentrating budget on promising chains and yielding higher next-action and executed-plan scores.
Progressive Efficiency Analysis. We sweep the step limit and record the dataset performance, wall-clock time and efficiency, defined the marginal gain per second, each budget in Figure 3 On Figure (a) Performance vs step limit, all methods improve with more steps, but ToolTree dominates every budget, with the largest margin in the low-mid regime of 16-64 steps before all curves begin to saturate, demonstrating the effectiveness of lookahead converting early expansions into higher-quality actions. On Figure (b) Running time vs step limit, runtime grows near-linearly for all methods. While ToolTree is slower than ReAct and Best-first, it is comparable to ToT and typically below LATS. Figure (c) Efficiency vy step limit, despite the extra time, ToolTree yields the highest peuuracypper-secondd especially from 16-32 and 32-64 steps, indicating better budget allocation. The pattern aligns with our design: pre-evaluation pruning removes implausible children before expansion and post-evaluation pruning trims unproductive branches after probes, together producing the best performance time trade-off and a practical sweet spot around 32-64 steps.
4.3 OPEN-SET TOOL PLANNING ON TOOLBENCH AND RESTBENCII
We compare ToolTree with Zero-shot, Chain-of-Thought, ReAct, DFSDT, and LATS on ToolBench and RestBench using GPT-4o-mini and GPT-4o. Following each benchmark's protocol, we report Pass Rate and Win Rate under identical instructions, a fixed retrieval setup, and budget parity. These benchmarks expose large, diverse API catalogs and require both API selection and argument com- position over executable REST endpoints, providing a clean stress test of planner scalability in many-API, real-world settings.
Results As demonstrated Table 2 ToolTree attains the best score across both datasets and mod- els. On ToolBench with GPT-4o, reaches 69.04 AVG, about +2.5 over the strongest baseline; RestBench-TTMDB, it achieves 74.50 AVG, about +3.1 over the next best. The advantage is largest where branching is high and plans span multiple calls. As method explores pre-evaluation to filter schema- or slot-incompatible calls before expansion, and applies post-evaluation to prune branches quickly using execution feedback, the resulting value backups favor API sequences that are compatible over longer horizons. In contrast, DFSDT and LATS either allocate depth without breadth-awar priors distribute rollouts less selectively, leading inaccurate planning and exe- cution. More results can be found in Appendix A Potential concerns related to metric coupling are discussed in Appendix A.9

---

Published as a conference paper at ICLR 2026
Rollouts
Nodes
Variant
Accuracy
Token Cost
60
Rollouts
555
Nodes
ToolTree
76.44
18.2k
100
Pre-pruning
75.28
20.4k
90
Pre-evaluation
71.80
21.1k
Post-pruning
75.82
22.9k
10
Post-cvaluation
68.94
22.9k
70
Both Pruning
74.58
24.1k
30
Both Evaluation
66.70
24.3k
Botter
Pte Pruning
Post Pruning
Both Pruning
Barteer
Pre Pruning
Post Fruning
Boih Pruning
Figure 4: Efficiency comparison of Tree and
Table Ablation of dual evaluation and bidi-
its pruning variants on nodes and rollouts.
rectional pruning on accuracy and token cost.
Retrieval Sensitivity. To isolate the impact of the shortlist, we replace the retriever with Contriever, RoBERTa, and BM25 and evalu- ate ReAct, ToT, and our planner on ToolBench, reporting the three official instruction groups (GI/G2/G3) as Table 4 While stronger retrieval lifts all methods, ours remains best across G1-G3 under every retriever. Besides, also found degradation under weaker trieval smallest for our planner, demonstrat- ing the effectiveness of both pre-evaluation and post evaluation on retrieved tool lists. We fur- ther attach the result for increasing tool library from 14 to 10014 in the Appendix A.10 to demonstrate its scalability.
Retriever
Method
G1
G2
G3
ReAct
61.0
78.0
72.5
Contriever
ToT
62.8
79.6
75.2
Ours
64.5
81.8
78.3
ReAct
60.5
76.5
73.0
RoBERTa
ToT
63.0
80.0
76.2
Ours
66.0
83.0
82.8
ReAct
58.2
74.1
69.4
BM25
ToT
60.1
76.0
71.8
Ours
62.4
79.0
74.2
Table Retriever ablation on ToolBench.
5 ANALYSIS
Effeet of dual evaluation and pruming. We ablate the effectiveness of dual evaluation and pruning under the same step limits and prompts on GTA with GPT-4o. Table shows that ToolTree attains the highest accuracy at the lowest token cost. Removing post-evaluation causes the largest accuracy drop by more than points, indicating that shallow execution feedback critical for steering search. Concurrently demonstrated in Figure 4 removing pre-pruning substantially reduces the median number nodes expanded to approximately 70 from 95 by directly curtailing unpromising branch explorations for narrower search tree.
Conversely, removing post-evaluation pruning substantially reduces me- dian rollouts to approximately 33 from 47, as its accurate rewards provide clearer solution quality signals for potentially earlier confident convergence. We provide further analysis on the robustness of using LLM judge for dual evaluation and pruning illustrated in Appendix A.6
ToolBench
Performance (9%)
20
Effect of Model Size on Planning. We study how backbone capacity inter- acts with our method by sweeping two open-source model families, LLaMA and Qwen, over increasing sizes on GTA and ToolBench. It can be seen in Figure 5 that performance scales monotonically with size for both families both datasets, with the steepest gains from small mid models and di-
Gwen-22. 2.3 3.0.8
Qwen- 5:330
Qwen-2 2.-1-25-11
Owen 0.141-28-148
2.5-148
Qwen:1.8.1 2.7788
Unms- 3.2-18
Ulama-3 3.2 3.2-38
Ulama-s
Llamw L-am-3--130
3-138
Lama 3-108
Figure 5:
Analysis of Performance with respect to model size on Qwen LLaMA family.
8

---

Published as a conference paper at ICLR 2026
Question:
Iterative Inferencing
Post Dost-Evaluation Reward
According to the sign, how many miles will travel from London to Poris?
"343 KM
iter.
343 KM
0.2 Low Reward
Image
p43
"94 KM
ster. 5
343 KM
Medium Reward
London Paris
Google
'30 KMP
343 km
Iter. 10
343
kim 376
213.75 miles
213/2 mics
High Reward
miles
Figure 6: A Sample Case of ToolTree on GTA.
minishing returns thereafter. Besides, we found that ToolBench is more size-sensitive than GTA as larger models help more when the planner must select among many APIs and ground longer argument strings.
Case Study. Tigure@ssowcasse how ToolTree progressively corrects itself on a GTA task. With the number of rollouts grows, ToolTree finds better tool trajectories guided by both the pre-evaluation score as the prior and the post-evaluation the sign, how many miles is it from London to Paris?"; the photo shows "343 km." In its first rollout, the agent invokes a lightweight OCR tool, passes the raw text to the LLM, and naively returns "343 km," " earning low post-evaluation score (0.2). By the fifth rollout, the search has inserted the patch-zoom tool to crop the numeric region and rerun OCR, but it still reports kilometers and receives only a medium reward (0.5). Guided by these signals, the tenth rollout adds a unit-conversion API after OCR; the calculator multiplies 343 x 0.621 371, and the LLM outputs the correct "213.75 miles," which the judge scores 0.9. More case studies are in Appendix A.8
score as the dominant reward. The query asks, "According
A.8
6 RELATED WORK
Tool Planning for LLM Agents. Dynamic tool planning is crucial for complex tasks that require the use of sequential tools (Qu et al., 2025). In order to mitigate such a problem, prompt-based methods leverage LLMs with their strong world knowledge priors (Hao et al., [023 Gu et al.)
2024) as a planner to select tools using in-content learning techniques. such as chain-of of-tho
(Wei et al. 2022 or ReAct (Yao et al. 2023b) schema (Shen al. 2003; Paranjape et al. 2023
Lu et al.) 2025). ). Even though flexible, these approaches often make greedy, single-step choices without adequate looking-ahead or backtracking, potentially leading hallucinated incorrect
actions (Qin et al. 2023 Liu et al., 2024). Alternatively, training-basse methods fine-tune models or add specific heads for tool invocation (Schick et al. 2023 Yang et al., (002)), incurring significant computational and data annotation costs. Trol departs fundamentally from linear pipelines by integrating the Eveluuaatioon score (rpre) directly into the UCT formula to dynamically steer exploration, while the Post- East--valatioon score (Fpoa) governs Backpropagation, together forming a non-linear, self-correeee self-correcting decision policy.
Augmenting LLM Agent with Tree Search. To address the limitations of reactive L.MM agents in complex tasks requiring lookahead (Gu et al. (2024), augmenting them with tree search provides deliberate planning layer. Various search algorithms, such as greedy search (Yao et al. 2023b), A
Search (Zhuang et al. 2024), Beam Search (Xie et al. 20023), MCTS (Zhou et al. 2024 Hao et al.)
2023). BFS/DFS Yao et al. 2023a), Best-first search KKhh et al. 2024) have been integrated at infer- ence time. However, these methods often lack sufficient tool invocation diversity for broad domain generalization. Our approach addresses this with explicit tree search for tool selection, contrasting with M-intenternal reasoning prevalent in prior methods, and further incorporates dual environmen-
9

---

Published as a conference paper at ICLR 2026
tal feedback for robust verification and plan refinement. One notable related work with Tool is Toolchain* (Zhuang et al. 2024), we attach more comparisons with Toolchain in Appendix B.3
CONCLUSION
This paper presents ToolTree, training- free agent framework that integrates a plug-and-ple MCTS-based tool planning module to enable robust multi-tool orchestration across diverse tasks. ToolTree explores dual feedback mechanism from the environment to provide nuanced guidance for MCTS, enabling both efficient search via strategic pruning and effective discovery of optimal tool trajectory. Experiments over 4 datasets across diverse domains of both closed-set and open-set tool planning demonstrate ToolTree consistently outperforms state-of-the-arr planning paradigm by 10 percent on average success rate. We hope this method will serve as a valuable foundation for future explorations into sophisticated tool orchestration and reasoning in more advanced Al agents.
Ethics Statement. We affirm adherence to the ICLR Code of Ethics. Our study uses only public benchmarks (GTA, m&m, ToolBench, RestBench) without human subjects or personally identifi- able data. API interactions
restricted to benchmark provvided virtual endpoints public test servers; no private user data or production systems are accessed. Potential risks include automation bias, unintended amplification of model biases, and misuse of automated tool-calling; this, we (i) pin evaluator versions and judge prompts, (ii) report multiple seeds and confidence in- tervals to avoid cherry-picking, (iii) release prompts/tool specs for external auditing, and (iv) follow dataset and API ficenses/ToS, We report compute budgets and runtime to encourage awareness of environmental cost. There are no conflicts of interest or external sponsorship that would bias work.
mitigate
Reproducibility Statement. We provide a complete specification of the problem setup and no- tation in SPreliminaries and the full algorithm (scoring, selection, widening, pruning, backups) with pseudocode and hyperparameters in SMethod. Experimental protocols (datasets, metrics, budgets, baselines), prompts/tool cards, retrieval settings. and evaluator configurations are detailed in SExperiments and the Appendix. We will release an anonymized repository containing code, prompts, tool specifications, evaluation scripts (including judge prompts/versions), seed control, and config files.
Acknowledgements This research was supported by the Korea Planning Evaluation Institute of Industrial Technology (KEIT) funded by the Ministry of Trade, Industry and Energy (No.RS- 2025-25458052, Development of Core Technologies for Manufacturing Foundation Models) and the Institute of Information & communications Technology Planning & Evaluation (IITP) grant funded by the Korea government(MSIT) NN..RS-202--022 bias
Development of self-evolving AI platforr based on international multidisciplinary governance)
REFERENCES
Andres M Bran, Sam Cox, Oliver Schilter, Carlo Baldassari, Andrew D White, and Philippe Schwaller. Chemcrow: Augmenting large-language models with chemistry tools. arXiv preprint wwXiv:2304.05376, 2023.
Tom Brown, Benjamin Mann, Nick Ryder, Melanie Subbiah, Jared D Kaplan, Prafulla Dhariwal, Arvind Neelakantan, Pranav Shyam, Girish Sastry, Amanda Askell, et al. Language models are few-shot learners. Advances in neural information processing systems, 33:1877-1901, 2020.
Xidong Feng, Ziyu Wan, Muning Wen, Stephen Marcus McAlcer, Ying Wen, Weinan Zhang, and Jun Wang. Aiphazero-like tree-search can guide large language model decoding and training. arXiv preprint 17911 2023.
Yu Gu, Kai Zhang, Yuting Ning, Boyuan Zheng, Boyu Gou, Tianci Xue, Cheng Chang, Sanjari Srivastava, Yanan Xie. Peng Qi, et al. Is your 1lm secretly a world model of the internet? model- based planning for web agents. arXiv preprint arXiv:2411. 1.06599, 2024.
10

---

Published as a conference paper at ICLR 2026
Shibo Hao, Yi Gu, Haodi Ma, Joshua Hong, Zhen Wang, Daisy Wang, and Zhiting Hu. Reasoning with language model is planning with world model. Houda Bouamor, Juan Pino, and Ka- lika Bali (eds.), Proceedings of the 2023 Conference Empirical Methods in Natural Language Processing, pp. 8155-8173, Singapore, December 2023. Association for Computational Linguis- tics. doi: 10. 10.18655./1122233mmmmmmmm
URL ht.ttts:: /acl antaaaaoohyy. oggpll/20oorrg233.33
emn mwin. 5077
Felix Helfenstein, Jannis Blüml, Johannes Czech, and Kristian Kersting. Checkmating one, by using many: Combining mixture of experts with mets to improve in chess. arXiv preprini arXiv:2401.1683 2024.
Levente Kocsis and Csaba Szepesvári. Bandit based monte-carlo planning. pp. 282-293, 2006.
Jing Yu Koh, Stephen McAleer, Daniel Fried, and Ruslan Salakhutdinov. Tree search for language model agents, arXiv preprint 17X11:2407.01476, 2024.
Binxu Li, Tiankai Yan, Yuanting Pan, Jie Luo, Ruiyang Ji, Jiayuan Ding, Zhe Xu, Shilong Liu, Haoyu Dong, Zihao Lin, and Yixin Wang. MMedAgent: Learning to use medical tools with multi-modal agent. In Yaser Al-Onaizan, Mohit Bansal, and Yun-Nung Chen (eds.), Findings of the Association for Computational Linguisties: EMNLP 2024, pp.
Miami, Florida, USA, November 2024. Association for Computational Linguistics. doi: 10. 1/533/122/// finding--emnlp.510. URL
2024 -enin.
510/
Xukun Liu, Zhiyuan Peng. Xiaoyuan Yi, Xing Xie, Lirong Xiang, Yuchen Liu, and Dongkuan Xu. Toolnet: Connecting large language models with massive tools via tool graph. arXiv preprint MXXv::2403.00839, 2024.
Yanming Liu, Xinyue Peng, Jiannan Cao, Shi Bo, Yuwei Zhang, Xuhong Zhang, Sheng Cheng, Xun Wang, Jianwei Yin, and Tianyu Du. Tool-planner: Task planning with clusters across multiple tools. In The Thirleenth International Conference Learning Representations, 2025. URL
https: /owprreiiee..........o.om net/ fowum??dddRRzciii.....
Pan Lu, Bowen Chen, Sheng Liu, Rahul Thapa, Joseph Boen, and James Zou. Octotools: An agentic framework with extensible tools for complex reasoning. arXiv preprint arXiv:2502.11277 2025,
Zixian Ma, Weikai Huang, Jieyu Zhang, Tanmay Gupta, and Ranjay Krishna. m & m's: A bench- mark evaluate tool-use for m ulti-step m ulti-modal tasks. In European Conference on Com- puter Vision, pp. 18-34. Springer, 2024.
OpenAl. Function Calling.
https://platform. www.oopp.eennoooaoopooop
Eurction-calling 2024. Online documentation.
Long Ouyang, Jeffrey Wu, Xu Jiang, Diogo Almeida, Carroll Wainwright, Pamela Mishkin, Chong Zhang, Sandhini Agarwal, Katarina Slama, Alex Ray, et al. Training language models to fol- low instructions with human feedback. Advances in neural information processing systems, 35: 27730-27744, 2022.
Bhargavi Paranjape, Scott Lundberg, Sameer Singh, Hannaneh Hajishirzi, Luke Zettlemoyer, and Marco Tulio Ribeiro. Art: Automatic multi-step reasoning and tool-use for large language models. arXiv preprini arXiv:2303.0901 2023.
Yujia Qin, Shihao Liang, Yining Ye, Kunlun Zhu, Lan Yan, Yaxi Lu, Yankai Lin, Xin Cong, Xiangru Tang, Bill Qian, al. Toolllm: Facilitating large language models master 16000+ real-world apis. arXiv preprint arXiv:2307. 16789, 2023.
Changle Qu, Sunhao Dai, Xiaochi Wei, Hengyi Cai, Shuaiqiang Wang, Dawei Yin, Jun Xu, and Ji- Rong Wen. Tool learning with large language models: A survey. Frontiers of Computer Science, 198344,,,43,, 2025.
Timo Schick, Jane Dwivedi- Yu, Roberto Dessi, Roberta Raileanu, Maria Lomeli, Eric Hambro, Luke Zettlemoyer, Nicola Cancedda, and Thomas Scialom. Toolformer: Language models can teach themselves to use tools. Advances in Neural Information Processing Systems, 36:68539- 68551, 2023.
11

---

Published as a conference paper at ICLR 2026
Yongliang Shen, Kaitao Song, Xu Tan, Dongsheng Li, Weiming Lu, and Yueting Zhuang. Hugging- gpt: Solving ai tasks with chatgpt and its friends in hugging face. Advances in Neural Information Processing Systems, 36:38 044438880,, 2023.
Noah Shinn, Federico Cassano, Ashwin Gopinath, Karthik Narasimhan, and Shunyu Yao. Reflexion: Language agents with verbal reinforcement learning. Advances in Neural Information Processing Systems, 36:8634-86333 8652, 2023.
David Silver, Aja Huang, Chris J Maddison, Arthur Guez, Laurent Sifre, George Van Den Driessche, Julian Schrittwieser, loannis Antonoglou, Veda Panneershelvam, Marc Lanctot, et al. Mastering the game of go with deep neural networks and tree search. nature, 529(7587):484 489, 2016.
David Silver, Julian Schrittwieser, Karen Simonyan, loannis Antonoglou, Aja Huang, Arthur Guez, Thomas Hubert, Lucas Baker, Matthew Lai, Adrian Bolton, et al. Mastering the game of go without human knowledge. nature, 550(76766:354-559, 2017.
Yifan Song. Weimin Xiong, Dawei Zhu, Wenhao Wu, Han Qian, Mingbo Song, Hailiang Huang, Cheng Li, Ke Wang, Rong Yao, et al. Restgpt: Connecting large language models with real-world 2023.
restful apis. arXiv preprint arXiv:2306.0660
Hugo Touvron, Louis Martin, Kevin Stone, Peter Albert, Amjad Almahairi, Yasmine Babaei, Niko- lay Bashlykov, Soumya Batra, Prajjwal Bhargava, Shruti Bhosale, et al. Llama 2: Open founda- tion and fine- chat models. arXiv preprint arXiv:2307. 092888, 2023.
Jize Wang, Ma Zerun, Yining Li, Songyang Zhang, Cailian Chen, Kai Chen, and Xinyi Le. Gta: benehmark for general tool agents. Advances Neural Information Processing Systems, 37: 75749-75790, 2024.
Jason Wei, Xuezhi Wang, Dale Schuurmans. Maarten Bosma, Fei Xia, Ed Chi. Quoc V Le, Denny Zhou, et al. Chain-of-thought prompting elicits reasoning in large language models. Advances in neural information processing systems, 35:24824 24837, 2022.
Chenfei Wu, Shengming Yin, Weizhen Qi. Xiaodong Wang, Zecheng Tang, and Nan Duan. Vi- sual chatgpt: Talking, drawing and editing with visual foundation models. arXiv preprint arXiv:2303.04671, 2023.
Yuxi Xie, Kenji Kawaguchi, Yiran Zhao, Xu Zhao, Min-Yen Kan, Junxian He, and Qizhe Xie. Self- evaluation guided beam search for reasoning, In seirth- Conference on Neural Information Processing Systems, 2023. URL
John Yang, Carlos E. Jimenez, Alexander Wettig, Kilian Lieret, Shunyu Yao, Karthik Narasimhan, and Ofir Press. Swe-agent: Agent-computer interfaces enable automated software engineering. Advances in Neural Information Processing Systems, 37:50528-50662, 2024.
Rui Yang, Lin Song, Yanwei Li, Sijie Zhao, Yixiao Ge, Xiu Li, and Ying Shan. Gpt4tools: Teaching large language model to use tools via self-instruction. Advances in Neural Information Processing Systems, 007771995-72000 2023.
Shunyu Yao, Dian Yu, Jeffrey Zhao, Izhak Shafran, Tom Griffiths, Yuan Cao, and Karthik Narasimhan. Tree of thoughts: Deliberate problem solving with large language models. Ad- vances in neural information processing systems, 36: 1 1809-11822, 2023a.
Shunyu Yao, Jeffrey Zhao, Dian Yu, Nan Du Izhak Shafran, Karthik Narasimhan, and Yuan Cao. React: Synergizing reasoning and acting in language models. In International Conference on Learning Representations (ICLR), 2023b.
Andy Zhou, Kai Yan, Michal Shlapentokh- Rothomn, Haohan Wang, and Yu-Xiong Wang. Lan- guage agent tree search unifies reasoning, acting, and planning in language models. In Ruslan Salakhutdinov, Zico Kolter, Katherine Heller, Adrian Weller, Nuria Oliver, Jonathan Scarlett, and Felix Berkenkamp (eds.). Proceedings of the 41st International Conference Machine Learn- ing, volume 235 Proceedings of Machine Learning Research, pp. 62138 62160. PMLR, 21-27 Jul 2024. URL https: http:::://proceeee ngs. ml www.prraapp. wwwpprtwwww.....p hhuuu httl]
12

---

Published as a conference paper at ICLR 2026
Agrot Framework
Angmented System
Agent
Hunoint
Refeetion
Tool Calling
Delibastic Teel Selestion
Ted Vestication
Ted Relinement
Tool Pruning
Table 5: A comparison of ToolTree with notable LLM agent frameworks, tool-augmented LLM systems and LLM agent search. Our method shows significant advantages in tool integration.
Shuyan Zhou, Frank F Xu, Hao Zhu, Xuhui Zhou, Robert Lo, Abishek Sridhar, Xianyi Cheng, Tianyue Ou, Yonatan Bisk, Daniel Fried, et al. Webarena: A realistic web environment for build- ing autonomous agents. arXiv preprini arXiv:2307. 13854, 2023.
Yuchen Zhuang, Xiang Chen, Tong Yu, Saayan Mitra, Victor Bursztyn, Ryan A. Rossi, Somdeb Sarkhel, and Chao Zhang. Toolchain Efficient action space navigation in large language models with a search. In The Twelfth International Conference on Learning Representations, 2024. URL wwtt/foounnn forum? Biw.mmddd-66pouuUTe.
attps://cpenzeet
A ADDITIONAL EXPERIMENT RESULTS
A.1 RESULTS ON AGENT FRAMEWORKS
We evaluate ToolTree against three distinct multi-tool orchestration baselines: Few-Shot prompting. HuggingGPT, and Octo Tools with two backbone models, GPT-4o-mini and GPT-4o. As covered in our evaluation spans 15 datasets in five diverse domains, including general visual, medical, external knowledge, math, and text/document.
6
GPT-4o-mini
GPT-4o
Domain
Dataset
Fow-Shot
HuggingGPT OctoTools ToofTree (Ours)
Few-Shot HuggingGPT Octo
ToolTree (Ours)
VQAv2
68.82
60.17
69 28
74.47
73.22
67.77
78.18
76.43
General Visual
GQA
63,80
65.13
66.
71.54
66.84
60.33
68.58
74.44
SQA
76.50
70.82
78.29
84.28
82.15
78.45
84.13
87.33
MedQA
79.14
84.33
18
91.13
83,20
86.73
93.88
Medical
VQA-Rad Rad
48.10
55. 14
60.10
63.27
54.47
58.88
66.42
74.12
24.90
40.72
43.13
47.12
26.20
37.82
46.17
50,86
OK-VQA
48.46
44. 19
50.17
55.38
$3.62
50.12
53.42
59.27
External Knowledge
A-OKVQA
60.28
55.81
62.15
70.54
65,91
60.33
68.33
73.48
WebQ
50.20
56.24
61.12
64.28
56.41
58.18
63.44
67.94
MATH
53.26
45.14
58.43
69.42
61.45
53.51
68.57
78.19
Math
Game-24
26.50
22.66
34.18
43.33
33.15
25.43
40.18
47.85
Vista
52.53
55.62
57.97
63.14
59.10
58.44
61.70
65.58
TextVQA
72.42
68.24
74.69
82.26
76.28
70.14
77.17
85.43
Text/ Doc.
DoA
83.28
83.10
84.23
89.43
87.11
82.13
89.39
92.33
HorpotQA
48.
54.15
43.77
51.82
56,33
Average
56.37
56.92
62.94
68.65
61.53
60.01
67.80
72.70
Table 6: Comparison across 15 datasets in five domains. ToolTrre consistently outperforms standard few-shot prompting, HuggingGPT, and OctoTools on both GPT-4o-mini and GPT-4o, achieving highest overall score.
Our framework consistently achieves superior performance across five domains. Under GPT-4o- mini, it attains an average of 68.65%, outperforming Few-Shot and HuggingGPT by over 11.7 points and Octo'Tools by 5.71 points on average. A similar trend is observed with the more capable GPT- 4o backbone, where ToolTree outperforms Few-Shot and HuggingGPT by more than 11.1 points and Tools by 4.9 points on average. Notably, ToolTree demonstrates substantial gains on tradi- tionally challenging, Nomain-sspecif datasets such as Path VQA and Game-of-24 with 22.22% and 16.83% performance gain compared with few-shot baselines under GPT-4o-mini. These significant improvements underscore the superiority of our framework that integrates domain specialized tool library and MCTS baase tool selector.
13

---

Published as a conference paper at ICLR 2026
Configuration
Vad
OK-VQA
Math
SQA
HotpotQA
AVG
LangChain
62.18
49.18
54.24
76.59
39.82
56.40
w/o COT-SC
65.14
54.37
56.88
82.17
44.90
60.69
w/o ReAct
66.28
52.33
59.25
80.95
45.18
60.80
w/o ToT
63.04
48.12
65.33
78.33
52.28
61.42
w/o ToolTree
67.72
54.27
65.74
81.33
51.94
64.20
MetaGPT
64.13
53.84
54.88
78.16
37.72
57.75
w/o COT-SC
68.74
54.88
60.30
79.44
46.90
62.05
w/o ReAct
66.32
55.11
58.94
80.54
49.56
62,09
w/o ToT
65.42
50.52
60.14
80.47
56.21
62.55
w/o ToolTree
69.24
55.83
62.28
82.57
54.77
64.94
Table 7: Comparison of ToolTree as plug-and-play module with ReAct, COT-SC and ToT modules. ToolTree achieves highest score on average.
A.2 PLUG-AND-PLAY MODULE COMPARISON
We evaluated our plug-and-play module ToodTrce-Modulc on one representative dataset from each of the five domains under two off-the-shelf LLM-agent frameworks, LangChain and MetaGPT. For each framework, we start from the vanilla agent with no extra tool use module and then insert ex- Caaeeess-hhhanofo--TTToooa
Self-Consistency (COT-SC), ReAct, Tree-of- Thought (ToT), or our proposed ToolTrre-Module-wwe holding all other settings like prompt format, tool APIs, number iterations/rraeectories,, and random seeds identical.
actly one of four
As Table shows, our Tool Moduue consistently achieves the highest overall average accuracy and outperforms all baselines on four out of five benchmarks across both frameworks, outperform- ing COT-SC, ReAct, and ToT by 3-8 points each dataset and 7 points average against the unaugmented agent. The only exception is HotpotQA, where thoouhht structured reasoning LLM's s hidden state excels systematically decomposing the multi-hop problem and exploring diverse evidence-linking pathways crucial for this dataset. Nevertheless, this internal state search than module in domain-specialized tasks that require external
nature also makes it far tools such as vision, medical and knowledge, where our module's 's versatile integration and adaptive orchestration these tools yields significantly better performance.
A.3 PERFORMANCE COMPARISON FOR EACH DOMAIN
Few-Shot
HuggingGPT
Tools
Ours
XL.
060
Average Performance (%)
SLT
61.3
15:0gp
50.2
$1.2
44.1
30
General
Medical
Knowledge
Math
Text/Doc
General
Medical
Knowledge
Math
Texb
Domain
Figure 7: Breakdown comparison for each of the domains.
Figure presents a detailed breakdown comparison of ToolTree's 's average performance across five specialized domains under two backbone models. ToolTree consistently achieves the highest per- formance across all domains, particularly excelling in the Math and External Knowledge domains. For example, in the Math domain under GPT-4o-mini, ToolTree reaches 63.4%, significantly outper-
14

---

Published as a conference paper at ICLR 2026
VQAv2
HotpotQA
GQA
Doc-VØA
16.9
SQA
7.7
TextVQA
5.7
MedQA
7.8
6.2
12.0
9.8
10.6
15.2
MathVista
VQA-Rad
6.9
16.8
9.9
10.3
22/2
G4me
PathVQA
14.1
MATH
OK-VQA
WebQ
A-OKVQA
Figure 8: Breakdown comparison with the few-shot baseline setup under GPT-4o-mini.
forming Few-Shot by 19.3%, HuggingGPT by 22.2%, and OctoTools by 11.2%. Similarly notable gains are observed under GPT-4o.
In the Medical domain, ToolTree surpasses HuggingGPT by 12.0% and OctoTools by 5.0% us- ing GPT-4o-mini, demonstrating its strength in tasks requiring specialized external knowledge and precise tool interactions. In the General Visual and Texi/Document domains, ToolTree continues show consistent improvements of roughly 5 7% baselines for both backbone models. These results underscore the robustness of ToolTree's 's MCTS-based tool selection and dual evalua- tion across diverse reasoning challenges.
A.4 PERFORMANCE COMPARISON WITH BASELINE
We measured ToolTree's 's per-dataset improvement over GPT-4o few-shot baseline by subtracting the baseline accuracy from ToolTree's accuracy on each of the fifteen tasks and plotting the results in Figure 8 The chart shows gains on every benchmark: Vath sits at the top with an uplift exceeding twenty points, followed by the Game of 24 and HotpotQA climbing into the mid-teens, and RQA-Rad and A-OKVQA rising by around 15% and 10% respectively. Even general visual tasks like VQAv2 and TextVQA register solid improvements of roughly six to eight points. This pattern reflects ToolTree's 's strength in orchestrating mullii-tep.. domain-specialized tool chains that essential for medical and mathematical puzzles, while its verification and pruning mechanisms consistently enhance performance
conventional downstream tasks.
15

---

Published as a conference paper at ICLR 2026
A.5 RESULTS ON APIBENCH
We further carried out additional results on APlbench to demonstrate its applicability in tool the invocation task as illustrated in Table g This confirms that our dual evaluation mechanism is not merely a pipeline heuristic but generalized hallucination filter. It successfully identifies and prunes invalid tool candidates zero-shot settings on completely unseen libraries, without the need for domain-specific fine-tuning
Table 8: APIBench results (BM25 retriever) for GPT-4o and GPT-4o-mini with different planning strategies. We report AST-based overall accuracy (%) on Hugging TensorHub, and TorchHub, well the macro-average accuracy and hallucination rate across the three subsets.
Backbone
Method
HuggingFace
TensorHub
TorchHub
Avg. Ace. (%)
Avg. Hallu, (%)
Zero-shot
68.4
59.2
44.5
57.4
22.1
ReAct
69.8
61.5
47.2
59.5
18.5
GPT-4o-mini
Theouhf-Thought
71.2
62.8
49,6
61.2
9.3
ToolTree (Ours)
73.5
65.4
53.1
64.0
7.4
Zero-shot
76.5
69.8
62.3
69.5
7.8
ReAct
77.2
71.0
63.5
70.6
5.1
GPT-4o
Troc-of-Thought
78.0
72.4
64.8
71.7
2.5
ToofTree (Ours)
79.2
74.1
66.5
73.3
2.1
A.6 ROBUSTNESS TO LLM-AS -LM-AS-JUDGE NOISE.
A potential vulnerability of ToolTree is its reliance on LLM-based judgment for pre- and post- evaluation. To quantify this risk, we conduct a restoration analysis on ToolBench, where we start from actual ToolTTee trajectories and counterfactually correct erroneous judge decisions on ran- dom subset of instances. We consider three variants: (i) selectively fixing false positives (rejecting tool calls that the judge incorrectly approved), (ii) selectively fixing false negatives (accepting tool calls that the judge incorrectly rejected), and (iii) an oracle setting where all judge decisions are corrected. Table 9 reports the judge error rate and task success rate for GPT-4o and GPT--4omini under these confi configurations.
Backbone
Configuration
Judge error rate
Task success (%,
ToolTree (baseline)
25.8%
51.9%
(-)
Fix false positives
7.4%
$2.5% (+0.6)
GPT-4o
Fix false negatives
18.4%
54.1%
(+2,2)
Oracle (perfect judge)
0.0%
54.7%
(+2.8)
ToolTree (baseline)
39.4%
49.5% (-)
Fix false positives
16.3%
50.8%
(+1.3)
GPT-4o-mini
Fix false negatives
23.1%
52.4%
(+2.9)
Oracle (perfect judge)
0.0%
53.6%
(+4.1)
Table 9: Restoration analysis of LLM-judge errors on ToolBench. "Judge error rate" is the fraction of incorrect pre-lpost-evaluation decisions. "Task success" the overall pass rate; A denotes the absolute difference (in percentage points) relative to the actual ToolTree baseline for each backbone.
The restoration results yield two main observations. First, TrolTree exhibits empirical tolerance to judge noise: despite non-trivial error rates (25.8% 9 for GPT-4o and 39.4% for GPT-4o-mini), the performance gap to an oracle judge is modest (at most +2.8 and +4.1 points, respectively). More- over, correcting only false positives yields limited gains, while correcting false negatives accounts for most of the improvement, indicating that overly conservative judgments are more harmful than permissive ones. Second, the search does not collapse under noisy judgments because the LLM signals enter the planner as soft guidance rather than ground truth: Tpee and "post are bounded priors inside the MCTS update, and their influence is aggregated over many rollouts. ToolTree repeatedly revisits and reevaluates actions, so isolated misjudgments are statistically smoothed out instead of being irrevocably baked into single greedy trajectory.
16

---

Published as a conference paper at ICLR 2026
Effect Post-Evaluation Model Accuracy
No post-evaluation
62.5
Post-eval: GPT4o-min
Post-eval: GPT4o
Post-eval. Gemini2
60.0
08.4
57.5
07.3
Average Accuracy
55.0
66.
53.1
52.5
50.0
48.5
47.5
45.0
ALL
Vision
Knowledge
Medical
Text/Document
Figure Effect of different L.LM for post evaluation.
Internal judge
Benchmark evaluator
ToolBench
RestBench
GPT-4o
GPT-4o
69.04
72.48
Gemini-2.5-Flash
GPT-4o
72.71
73.12
LLaMA-333-70B
GPT-4o
46.48
50.17
LLaMA-3.3-70B
LLaMA-3.3-70B
38.11
41.64
Table 10: Cross-vendor / cross-judge robustness of ToolTree on ToolBench and RestBench (pass
rate %). We vary the internal judge used during planning and the external benchmark evaluator.
A.7 EFFECT OF DUAL FEEDBACK ON ACCURACY
We measured how the choice of post-evaluation model affects overall and domain domain-specific accuracy by running the MCTS pipeline under four settings: no post-evaluation. GPT-4o-mini judge, GPT- 4o as judge, and Gemini 2.0 as judge, as shown in Figure 9 Across all tasks, accuracy steadily increases with more powerful judges, rising from 54.2% to 60.8% (Gemini 2.0). The largest im- provements appear vision and text/document tasks, where nuanced output verification matters most. These results show that richer post-execution feedback enables the agent to better discrimi- nate useful tool calls, leading to more accurate final answers.
A.8 ADDITIONAL CASE STUDY
We show more cases of ToolTree on the evaluation benchmark as shown in Figure
A.9 CROSS- VENDOR CHECK ON POTENTIAL METRIC COUPLING
A potential concern is that ToolTree might overfit to the particular LLM judge used during plan- ning. especially when the same model family is also used as the benchmark evaluator. To test this, conduct cross-vendor ablation where vary the internal judge used by ToolTree (GPT-4o, Gemini-2.5-Flaase LLaMA-3.3-70BB and the external evaluator (GPT-4o vs LLaMA-3.3-700 ToolBench and RestBench. As shown in Table TO decoupling the judge from the evaluator
on
17

---

Published as a conference paper at ICLR 2026
Question:
HuggingGPT Greedy Search
Does this person have risk of lung cancer not?
Ovargenerolized captions.
Image Capdloning
image of
No Risk!
fine-grained Information.
Heuristic Search
Image
Object Ontection
Shallow heuristics
magees Cougle
No
MCTS Planned
terillinn
Encigpssig
Foceliy
Medical
Medical Slng.
iPtt
Yes, risk of lung detected.
LUng X roy umoge
(a) Example inference trajectory for a medical VQA query.
Question:
HuggingGPT - Greedy Search
What sort of building seen behind this amusement?
image Captioning
Office building
Relied on broad description, missing lago details
Heuristic Search
Image
Drandgere
Gooigl
Aetinn and
Only consider most prominent text
-Panned
Google
IC
glaba! Jannic services fimm
Financial building
(b) Example inference trajectory multi-hop reasoning query.
Figure 10: Two qualitative case studies showcasing ToolTree's iterative tool orchestration on (a) radiology image question and (b) a multi-hop knowledge reasoning task.
improve performance. contrast, tightly coupling LLaMA-3.3-70B as both judge and evaluator degrades pass rate. These patterns suggest that ToolTree primarily benefits from higher-quality rea- soning signals rather than exploiting a specific evaluator.
A.10 EFFECT OF TOOL LIBRARY SIZE.
While our ToolBench experiments (over 16k tools) already demonstrate large-scale capability, we also conduct controlled stress test to directly examine ToolTree's robustness to growing tool li- braries and noisy tools. Starting from small closed-set configuration with task-relevant tools, progressively inject distractor tools drawn from unrelated domains, increasing the total library size up to 10,014 tools. For each setting, we report the average Fl score and the relative perfor- mance drop compared to the 14-tool baseline. As shown in Table II even when the library size increases by three orders of magnitude, the performance degradation remains below 2%, indicating that ToolTree's 's pre-evaluation module effectively filters out irrelevant tools from large pool. As the pre-evaluator scores tools based on semantic relevance rather than raw frequency, we can fix the pruning thresholds it continue function reliably across all scales. This bridges the gap between
18

---

Published as a conference paper at ICLR 2026
Added distractors
Total tools
Selection strategy
Avg. F1 (%)
Rel. drop
0 (baseline)
14
Direct context
55.89
/
Direct context
55.74
-0.15%
+100
114
Retrieval (Top-20)
55.15
-0.74%
+1,000
1,014
Retrieval (Top-20)
54.82
-1.07%
+10,000
10,014
Retrieval (Top-20)
54.27
-1.62%
Table 11: Stress test on tool library size. We start from a 14-tool baseline and progressively add distractor tools. "Avg. FI" denotes average task performance, and "Rel. drop" is the relative perfor- mance decrease compared to the 14-tool baseline.
our small closed-set benchmarks (e.g.. GTA) and large spen-set scenarios (e.g., ToolBench), and supports ToolTree's viability for massive, real-world tool libraries.
B EXPERIMENT DETAILS
B.1 BENCHMARK DATASET
We provide comprehensive descriptions of the datasets and baseline methods used in the main ex- periments. This appendix serves a reference understand the task setups, evaluation modes, and implementation details for reproducibility and further analysis.
B. CLOSED-SET TOOL PLANNING BENCHMARKS
GTA (General Tool Agent) (Wang et al. 2024.. GTA is benchmark designed evaluate general- purpose tool use in LLM agents. defines a fixed set of 14 APIs with well-typed input/output schemas and multi-hop compositional tasks, Each task requires the agent invoke a series of tools in logical order to complete the goal. GTA is evaluated under two modes:
Step-by-step mode: Agents plan tool usage iteratively, predicting both the tool and its arguments each step.
End-to-end mode: Agents must generate the full tool call sequence single pass.
m&m (Multi-modal and Multi-step Tool Use) (Ma et al. 2024). The m&m dataset features 33 APIs spanning vision, text, and arithmetic tasks. Each task involves integrating multiple modali- ties (c.g., images, structured text) and planning tool usage over longer horizons. The benchmark emphasizes input schema matching and argument consistency in tool sequences.
B.2 OPEN-SET TOOL PLANNING BENCHMARKS
ToolBench (Qin et al. 2023). ToolBench a large-scale benchmark that focuses on open-set tool planning with real-world APIs. It consists of 16,464 APIs extracted from online documentation. Each task includes a natural language query, and the agent must 1) retrieve relevant APIs from the entire pool (tool retrieval); 2) generate valid input arguments; and 3) compose executable tool sequences to solve the task. Evaluation follows a judge-based protocol with Pass Rate (correct solution) and Win Rate (head-to-head comparison against baselines).
RestBench (Song et al. 2023). RestBench evaluates agent performance over RESTful APIs in two domains: TMDB (movie database) and Spotify. Unlike ToolBench, the API pool is smaller (143 endpoints), but tasks still require multi-step planning, slot filling, and reasoning over endpoint chains. Evaluation is similar to ToolBench.
B.3 BASELINE METHODS
Zero-Shot. A vanilla LLM is prompted directly with the task instruction and available tools, without additional planning prompting heuristics. This serves lower-bound baseline.
19

---

Published as a conference paper at ICLR 2026
ReAct (Yao al. 2023b). This method combines reasoning offainn-f-tthughi and acting (tool invocation) in an interleaved fashion. At each step, the model generates intermediate reasoning followed by tool calls. It is greedy and reactive, without explicit planning.
Chain-of- Thouuhh (CoT) (Wei et al. 2022). CoT decomposes the task via intermediate reasoning steps, but without tool calls. In the context of tool planning, it is extended select tools after each reasoning span.
Best-First Search (Koh et al. 2024). A tree-based search method that prioritizes the expansion of most promising partial plans using heuristics. It expands the most likely paths but does not account for long-term reward rollout diversity.
Tree-of-Thought (ToT) Yao et al., 2023a). A general planning paradigm where LLM LLM--genrrtee thoughts are expanded into search tree, with scoring used backtrack and explore multiple op- tions. ToT treats internal LLM reasoning as planning units, not actual tool execution.
A Search (Zhuang et al. 2024). Adapts A to the tool planning problem by defining heuristic function over action sequences. It explores the search space by balancing cost so far and expected utility, assuming an accurate reward heuristic. ToolTree conceptually related to ToolChain*, which applies A* search over tool sequences guided by single heuristic score computed before execution. However, search commits to best-first expansion based on this heuristic and cannot easily revise early decisions if the heuristic is misaligned with actual tool behavior. In contrast, ToolTree uses MCTS to repeatedly sample and update action values, which allows recovery from early mistakes. Moreover, ToolTree explicitly separates prior score Tpre (used for pre-pruning and exploration) from a grounded post-execution reward Tpos (used for backpropagation and post-pruning), enabling the planner to discard branches that appear promising in theory but fail in practice. Finally, instead of relying only on queue ordering, ToolTree performs explicit bidirectional pruning before and after tool calls to reduce error propagation and tool cost.
LATS (Language Agent Tree Search) (Zhou et al. 2024). LATS a framework that combines tree search with tool execution, using LLM-guided rollouts and post-hoc scoring prune weak branches. Unlike ToolTree, it lacks pre-evaluation before tool execution.
DESDT QQin al. 2023). This is a strong open-set baseline designed for ToolBench, where the agent uses a depth- first symbolic planner over retrieved APIs, guided by LLM scoring. It focuses on execution consistency rather than search efficiency.
B.4 MODEL AND EVALUATION PROTOCOI.
All baselines are implemented under the same backbone model settings (GPT-4o and GPT-4o-mini.. For closed-set tasks, the tool APIs are pre-defined and shared with all models. For open-set tasks, we use fixed Top-K API retrieval (K=20) and identical prompt formats. We report:
Closed-set: Tool F1, Argument F1, Plan F1, and Execution F1.
Open-set: Pass Rate and Win Rate, averaged over three instruction templates.
Hyperparameter Setting. Evoked by Zhou et al. 2024). during MCTS we set the exploration constant to À = 1.4, allow at most Rmax = 60 roll-outs, and prune branches whenever Tpre < 0.3 or Ypost < 0.44 search stops early if the best Q value increases by < 10-3 over 10 consecutive roll-outs.
B.5
TOOL LIBRARY
Table ?? summarizes the external tools and models integrated within the ToolTree library, catego- rized by their domain specialization. The library offers broad coverage across general visual under- standing, knowledge-based VQA, medical QA. mathematical reasoning, and text/document tasks. For each domain, a diverse set of functions, ranging from object detection and image segmentation to knowledge graph querying, medical report generation, and OCR, is supported by state-of-the. art models and APIs. This comprehensive and modular toolset enables ToolTree to handle a wide spectrum of complex, multi-modal tasks with domain- precision.
20

---

Published as a conference paper at ICLR 2026
B.6
TOOL CARD METADATA EXAMPLE
We hereby attach the metadata for the medical object detection tool illustrative example in Table 12
Field
Type
Deseription / Example
tool_name
string
"Nedical [rodiccal,bjectttc. Detection"
description
string
A tool that detects the organs within a given medical image, such as CT, MRI, X-Ray and pathology images.
image:
Path the image file (e.g. "lung cancer Image png") Prompt to guide detection (default: "Detect the organs in the given image.")
input
prompt: str
output
dict
Detected organs with their bounding box, organ name, and confidence score.
input output
example
="name"="left lung", :onfidence=:0.8222
"bounding box"; 31,
"object_2": ("nime"""right
lung", "bounding box": [oxx:[[5]) (8,,,48, 35, 98], :onffidence":..822
Table 12: Metadata schema for the Medi cedicaal.bjectt.eeeeeeee tool.
B.7 PRE-PRUNING JUDGE PROMPT FOR FPrE
System message
Role. You are strict tool- planning judge for a language-agent that solves user tasks by calling tools in sequence.
Inputs. You are given:
the original user query and current conversation context;
tool card (name, description, I/O schema, examples);
concrete argument draft that is syntactically valid for the tool.
Output format. You must output a single JSON object with:
"score": ": real number between 0.0 and 1.0 (inclusive) measuring how promising this tool call is before running it;
"expl exxplanation" a brief natural-languee justification (2-4 sentences).
Scoring guideline. Use coarse scale [0, 1]. There is no need to finely distinguish every small difference; choose value that roughly reflects your judgment of usefulness.
What to penalize. Give low scores to candidate tool calls that:
mismatch the required modality or domain;
ignore key constraints required fields in the schema;
duplicate previous call with effectively identical arguments and no clear new benefit;
are speculative when more direct or specific tool is available.
Important. Do not simulate the tool output; you are judging only the promised usefulness of this tool call the next action.
21

---

Published as a conference paper at ICLR 2026
User message template
Construct the user message to the judge with the following structure. Context.
User query: ISER-QUERY
Current dialog / planning context: CURRENT,CONTEX,
Candidate tool card.
Name: TOOL NAME
Description: TOOL DESCRIPTION
Input schema: TOOL_INPUT__SCERA
Output schema: TOOL.OUTPUT.SCHEM.
Example uses (if any): TOOL EXOMPLES
Candidate argument draft.
Arguments to pass into the tool: ARGUMENT CWWUWEEN.DRAFT.SSSS DRAFT.JSON
Then ask the judge:
Task: Decide how promising it is to execute this tool call next for solving the user's query, given the current state of the conversation and prior tool calls. Please respond only with a JSON ob- ject of the form ("score"; <float between O. 0 and 1.0>, "explanation": " 222--4 sentence explanation>?)
B.8 POST-PRUNING JUDGE PROMPT FOR TYOST
System message
Role. You are strict tool-planning judge for a language-agent that solves user tasks by calling tools in sequence.
Inputs. You are given:
the original user query and conversation context before the call;
the tool card;
the concrete arguments that used;
the actual tool output.
Output format. You must output single JSON object with:
"score": a real number between 0.0 and 1.0 (inclusive) measuring the grounded utility of this executed tool call;
"explanatio inn ": brief natural-languaee justification (2-4 sentences).
Scoring guideline. Use coarse scale in [0. 1]. Choose value that roughly reflects how helpful this call was; you do not need to finely distinguish very small differences.
When assigning the score, consider:
Task-consistency: does the output address the user's query or current sub-goal?
Correctness plausibility: are there obvious errors or contradictions?
Relevance: is the output focused on what needed now, rather than generic or noisy?
Constraint satisfaction: does it respect safety, formatting, and domain constraints?
Important. You are judging only this tool call's incremental contribution from the previous context to the new context. Do not re-evaluate the entire plan.
22

---

Published as a conference paper at ICLR 2026
User message template
Construct the user message to the judge with the following structure.
Context.
User query: USER-QUERY
Dialog/ / planning context before this call:
Executed tool card.
Name: TOOL NAME
Description: TOOL DESCRIPTION
Input schema: TOOL_INPPU_SSCEMA
Output schema: TOOL.OUTPUT.SCHEM.
Example uses (if any): TO0L_EXAMPLE,
Call details.
Arguments actually used: ARGUMENT.JSON
Tool output (raw):
RAW
Then ask the judge:
Task: Evaluate how much this executed tool call actually helped with solving the user's query, considering correciness, relevance, and progress loward a final answer. Please respond only with a JSON object of the form ("score": <float between 0. O and 1.0>, "explas texplanate io "<2--4 sentence explanation>").
23


Reviews:
[{"review_id": "t01AF2z06h", "reviewer": "Reviewer_DAct", "summary": "This paper proposes ToolTree, a planning-time framework that casts multi‑tool orchestration for LLM agents as an MCTS-style search augmented with dual LLM feedback.", "questions": "1. There are several minor typesetting errors (e.g., “Eq. equation 1”, “backward‑prorogation”, “Table ??”) and occasional ambiguity in the formalism in §2–§3, which can impede exact reproducibility absent code.", "limitations": "", "rating": 6, "confidence": 3, "soundness": 3, "presentation": 3, "contribution": 2, "strengths": "1. This paper is well written and easy to follow\n\n2. The prior‑augmented UCT and bidirectional pruning are straightforward and training‑free.", "weaknesses": "1. This method is somehow similar to ToolChain*; needs more clarification on the difference and comparison.\n\n2. The method’s post‑evaluation judge (used during planning) may be architecturally similar to, or the same family as, the benchmark evaluator (Pass/Win are also judge‑based in ToolBench/RestBench). Even with version pinning, this can unintentionally optimize for the judge rather than ground truth. The authors partially probe judge choice but further cross‑judge / cross‑vendor sanity checks would reduce concerns about metric coupling.  \n\n3. The paper claims budget parity and shared prompts/tool sets, but some baselines (e.g., LATS, ToT) might benefit from comparable pre‑gating by schema/type or caching; it’s unclear whether the authors provided similarly favorable engineering to competing methods.", "quality": null, "clarity": null, "significance": null, "originality": null, "strengths_and_weaknesses": "", "was_revised": false, "final_justification": "", "rebuttal": "", "claims_and_evidence": "", "methods_and_evaluation_criteria": "", "theoretical_claims": "", "experimental_designs_or_analyses": "", "relation_to_broader_scientific_literature": "", "essential_references_not_discussed": "", "other_strengths_and_weaknesses": "", "other_comments_or_suggestions": "", "questions_for_authors": "", "summary_of_paper": "", "summary_of_recommendation": "", "technical_quality": "", "clarity_of_presentation": "", "potential_impact": "", "robotics_focus": "", "quality_of_limitations": "", "questions_for_rebuttal": "", "reasons_to_accept": "", "reasons_to_reject": "", "questions_to_authors": "", "extra_scores": {}}, {"review_id": "xApW4rG9dj", "reviewer": "Reviewer_fWZR", "summary": "In this paper, the authors present ToolTree, a Monte Carlo tree search-inspired planning paradigm for tool planning. ToolTree explores possible tool usage trajectories using a dual-stage LLM evaluation and bidirectional pruning mechanism—this mechanism enables the agent to make informed, adaptive decisions over extended tool-use sequences while pruning less promising branches both before and after tool execution. Empirical evaluations conducted by the authors across both open-set and closed-set tool planning tasks demonstrate that ToolTree consistently improves performance while maintaining the highest efficiency.", "questions": "please refer to Weaknesses", "limitations": "", "rating": 6, "confidence": 3, "soundness": 3, "presentation": 3, "contribution": 3, "strengths": "1.  Bidirectional pruning enables precise cost control by filtering low-value branches, and a dedicated caching mechanism minimizes redundant computations.\n2.  Without depending on task-specific training, the framework maintains robust adaptability across diverse tool libraries—thus eliminating the need for retraining when switching between different tool sets.\n3.  Evaluations spanning both closed-set and open-set tool planning tasks across 4 benchmarks consistently demonstrate the framework’s superior performance.", "weaknesses": "1.  The reliability of both *r\\_pre* and *r\\_post* hinges entirely on the LLM’s ability to assess tool relevance and output quality, introducing risks if the LLM misjudges context or utility.\n2.  When handling an extremely large number of open-set tools, pre-evaluation incurs significant sorting overhead, as the system must process and rank a massive volume of tool candidates.", "quality": null, "clarity": null, "significance": null, "originality": null, "strengths_and_weaknesses": "", "was_revised": false, "final_justification": "", "rebuttal": "", "claims_and_evidence": "", "methods_and_evaluation_criteria": "", "theoretical_claims": "", "experimental_designs_or_analyses": "", "relation_to_broader_scientific_literature": "", "essential_references_not_discussed": "", "other_strengths_and_weaknesses": "", "other_comments_or_suggestions": "", "questions_for_authors": "", "summary_of_paper": "", "summary_of_recommendation": "", "technical_quality": "", "clarity_of_presentation": "", "potential_impact": "", "robotics_focus": "", "quality_of_limitations": "", "questions_for_rebuttal": "", "reasons_to_accept": "", "reasons_to_reject": "", "questions_to_authors": "", "extra_scores": {}}, {"review_id": "N4o5q2jS1v", "reviewer": "Reviewer_zEaV", "summary": "The paper introduces ToolTree, novel methods for Monte Carlo Tree Search-based planning with two tree pruning mechanisms: evaluation before tool calling (\"pre-pruning\") acts as foresight by avoiding low-promise children, whereas evaluation after tool calling (\"post-pruning\") acts as hindsight by trimming branches disproven by evidence. Experimental evaluations on four benchmarks, including closed-set (GTA and m&m) and open-set (ToolBench and RestBench) tool planning tasks, demonstrate that ToolTree largely outperforms a broad range baselines, which span LLMs with greedy decoding, ReAct-based planning, more simple tree-based planning such as ToT, and more sophisticated tree-based planning such as A*. ToolTree is shown to achieve better accuracy-per-second performance, and the paper includes thoughtful and comprehensive ablation studies that help to understand how the methods behave as a function of design choices, model scale, and backbone evaluating LLMs.", "questions": "What is the combination of pre-evaluation LLM judge and post-evaluation LLM judge used through Section 4?", "limitations": "", "rating": 8, "confidence": 4, "soundness": 4, "presentation": 3, "contribution": 3, "strengths": "1. Making tool planning more efficient via cost-effective tree pruning is a relevant and timely topic, and the paper is particularly well motivated.\n\n2. The paper has a clear organization and is mostly well-written (see improvement suggestions further below), making it easy to follow. For example, lines 230-235 are particularly effective in summarizing the main ideas detailed through Section 3.\n\n3. The choices of benchmarks and baselines feel sound and thoughtful, yielding interesting analyses. They comprise both closed- and (relatively) open-set tool planning, with two benchmarks each; and a broad range of alternatives, namely, LLMs with greedy decoding, ReAct-based planning, more simple tree-based planning (e.g., ToT), as well as more sophisticated tree-based planning (e.g., A*). Ablations are also sensible and informative.\n\n4. Overall, this is a strong paper submission on the basis of the idea novelty and description, experimental soundness, and results and analyses, with small improvement opportunities w.r.t. presentation as described below.", "weaknesses": "1. An important implementation detail that remains unclear is the combination of \"lightweight pre-evaluation LLM judge\" (per lines 211-213) and \"possibly stronger LLM judge\" (per lines 221-222) used through Section 4. There is a study in the Appendix A.6, but that doesn't quite clarify what exactly is behind Section 4. It would also be useful to add the prompting/instantiation details to the Appendix, for reproducibility.\n\n2. Writing can be improved with more proofreading, specifically:\n\ni. On line 407: the Table reference is missing. The entire block should refer to Figure 4, whose reference is also missing.\n\nii. On Table 1: under \"m&m > Step-by-step > Arg,\" the value for A* is 71.85 and therefore higher than the result highlighted for ToolTree, so this specific highlight should be fixed for correctness.  \n\niii. On lines 344-345: the budget values in Figure 3 are not clear. It would be helpful to add ticks and tick values on the x-axis that align to the budget marks, since we are referred to Figure 3 for this information.\n\niv. On line 367: typo \"explores uses.\"\n\nv. On line 349: typo \"While (...) Best-First, yet comparable (...)\"\n\nvi. On line 248: typo \"where each providing (...)\"\n\nvii. On line 245: typo \"is spans.\"\n\nviii. On line 155: typo \"back propogation.\"\n\nix. On line 78: typo \"per cent.\"", "quality": null, "clarity": null, "significance": null, "originality": null, "strengths_and_weaknesses": "", "was_revised": false, "final_justification": "", "rebuttal": "", "claims_and_evidence": "", "methods_and_evaluation_criteria": "", "theoretical_claims": "", "experimental_designs_or_analyses": "", "relation_to_broader_scientific_literature": "", "essential_references_not_discussed": "", "other_strengths_and_weaknesses": "", "other_comments_or_suggestions": "", "questions_for_authors": "", "summary_of_paper": "", "summary_of_recommendation": "", "technical_quality": "", "clarity_of_presentation": "", "potential_impact": "", "robotics_focus": "", "quality_of_limitations": "", "questions_for_rebuttal": "", "reasons_to_accept": "", "reasons_to_reject": "", "questions_to_authors": "", "extra_scores": {}}, {"review_id": "NNDX9StIJc", "reviewer": "Reviewer_X8ME", "summary": "This paper proposes ToolTree, an MCTS-inspired framework for LLM tool planning, aiming to solve the shortcomings of current methods—greedy strategies lack long-term foresight and search-based methods are inefficient. ToolTree integrates dual feedback (pre-execution scoring to predict tool utility before invocation and post-execution scoring to assess actual output value) and bidirectional pruning (cutting unpromising branches before and after tool execution) into an iterative search process. Evaluated on 4 benchmarks (GTA, m&m for closed-set tool planning; ToolTree, RestBench for open-set) with GPT-4o and GPT-4o-mini, ToolTree consistently outperforms baselines: it achieves 66.95 F1 on GTA, 69.04 pass rate on ToolBench, 88.61 average F1 on m&m, and 74.50 average on RestBench-TMDB with GPT-4o, while having the highest accuracy-per-second. Ablation shows dual evaluation and pruning are critical.", "questions": "Please refer to above, I think this paper requires a significant revision.", "limitations": "", "rating": 2, "confidence": 4, "soundness": 2, "presentation": 1, "contribution": 1, "strengths": "1. The work accurately identifies the \"short-sightedness\" and \"inefficiency\" pain points in LLM tool planning, and the proposed MCTS framework with \"dual-feedback evaluation + bidirectional pruning\" is highly targeted, forming a logically closed-loop innovative solution.\nIt performs remarkably well in balancing performance and efficiency, outperforming the state-of-the-art on four benchmark datasets while achieving the best \"accuracy per second\", thus balancing effectiveness and practical applicability for deployment.\n2. It performs remarkably well in balancing performance and efficiency, outperforming the state-of-the-art on four benchmark datasets while achieving the best \"accuracy per second\", thus balancing effectiveness and practical applicability for deployment.", "weaknesses": "I have a series of questions and concerns regarding this work.\n\n1. Currently, this work only focuses on improving MCTS for tool invocation. Given the abundance of similar prior studies, its core innovation is not prominent—it feels more like adding refined pre-processing and post-processing steps to the existing MCTS workflow. Overall, it seems to trade off some inference latency and use more token-based reasoning to achieve better results. From the comparison figures, can we consider pruning as its core contribution? The description of the pruning component is also insufficient: beyond understanding that more detailed reasoning is used to decide whether the model should execute a tool (thus affecting latency), what additional insights does this work provide?\n2. The experimental analysis is inadequate. It focuses mostly on dataset-based measurements and lacks in-depth ablation studies on the modules added in the paper. This makes it difficult to identify the exact source of the advantages brought by these new modules.\n3. The experimental metrics are questionable. I paid special attention to metrics like Tool F1, which is defined as the accuracy of tool selection and its alignment with the \"standard answer.\" Does tool invocation always have a \"perfect answer\"? Strictly speaking, what we need is an evaluation of whether a tool fulfills its intended function—how exactly are the standard answers annotated? The Arg F1 metric (alignment of input parameters) is also problematic: input parameters can vary under different scenarios, so this metric is overly rigid and fails to truly assess whether the proposed ToolTree method is effective.\n\n4. Insufficient clarification on tool library dependency: The paper mentions that ToolTree integrates a domain-specialized tool library (e.g., BioMedParse for the medical field and Wolfram Alpha for the mathematical field), yet it fails to analyze the correlation between tool library scale and performance. For instance, when the number of tools in the library scales from dozens to thousands, will the \"tool filtering efficiency\" during the pre-evaluation stage decrease? Do the thresholds for bidirectional pruning need to be dynamically adjusted based on the size of the tool library? The existing experiments do not provide such key information, which limits the understanding of the method’s scalability.\n\n5. Weak compatibility with low-resource models: Although the experiments include GPT-4o-mini, the results show that the magnitude of its performance improvement (e.g., Tool F1 on the GTA dataset is only 67.83, a significant gap compared to GPT-4o’s 79.26) is far smaller than that of high-resource models. The paper does not analyze the reasons for the performance degradation of \"dual-feedback evaluation\" under low-resource models—whether it is due to the insufficient accuracy of pre-evaluation by lightweight LLMs or the limited ability of post-evaluation to judge outputs. Nor does it propose optimization solutions for low-resource models, reducing the practicality of the method in scenarios with limited computing power.\n\n6. Failure to discuss the recovery mechanism for error propagation: While the paper claims that ToolTree can \"recover from early mistakes,\" it does not specify the recovery logic. For example, if a tool invocation in a certain step leads to output deviation due to minor parameter errors (such as unit mistakes), how can subsequent steps identify and correct this error through dual feedback? Will it re-invoke the tool, adjust parameters, or switch the tool chain? The existing experiments do not design such \"error injection\" scenarios, making it difficult to verify the effectiveness of its error recovery capability.\n\n7. The entire paper is extremely rough, as if it has not undergone any revision or proofreading. For example, in line 104, \"t1\" and \"lib\" lack proper subscripts; in lines 272–273, the red highlighting exceeds column boundaries; in line 407, there is a missing figure reference for \"Table ??\"; and there are numerous other minor issues. A major revision is strongly recommended.", "quality": null, "clarity": null, "significance": null, "originality": null, "strengths_and_weaknesses": "", "was_revised": false, "final_justification": "", "rebuttal": "", "claims_and_evidence": "", "methods_and_evaluation_criteria": "", "theoretical_claims": "", "experimental_designs_or_analyses": "", "relation_to_broader_scientific_literature": "", "essential_references_not_discussed": "", "other_strengths_and_weaknesses": "", "other_comments_or_suggestions": "", "questions_for_authors": "", "summary_of_paper": "", "summary_of_recommendation": "", "technical_quality": "", "clarity_of_presentation": "", "potential_impact": "", "robotics_focus": "", "quality_of_limitations": "", "questions_for_rebuttal": "", "reasons_to_accept": "", "reasons_to_reject": "", "questions_to_authors": "", "extra_scores": {}}]

Author rebuttal:

Decision: Accept (Poster)