acceptodds
Under review as a conference paper at ICLR 2027

TaReD: Tool-Aware Recursive Decomposition for Long-Horizon Tasks

Abstract

Agents combine reasoning with tools to interact with external systems and complete real-world tasks. Early agents typically interleave reasoning and actions along a single execution chain. On complex tasks, this chain becomes unreliable because growing histories obscure intermediate dependencies and allow early planning errors to propagate. Recursively decomposing a complex task into smaller subtasks offers a natural solution, yet effective decomposition must account for the system's capabilities so that each subtask can be executed by the available tools. In realistic systems, however, tool libraries can be too large to expose in full. Injecting every tool description consumes substantial context while making relevant tools harder to retrieve and useful task boundaries harder to identify. We propose tool-aware recursive decomposition, which organizes tools by functional relationships into a hierarchy of capabilities. During execution, the agent discovers tools on demand and uses the hierarchy to recursively decompose a complex task into a subtask tree whose levels are aligned with the capabilities required at each stage. Experiments on complex real-world tasks show that the proposed method improves end-to-end task success rate by up to 40 percentage points over the compared baselines.

Primary area:
applications to robotics, autonomy, planning
Keywords:
Agent, Recursive Task Decomposition, Long-Horizon Task Execution

Reviews

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

TaReD addresses long-horizon tool-using tasks in settings where exposing the entire tool library is impractical. It organizes tools into a hierarchy of capabilities, discovers relevant capabilities on demand, and uses this information to guide recursive task decomposition. Detailed tool contracts are bound when an execution stage is ready, and references to intermediate results support dependencies between subtasks. The hierarchy contains 137 category nodes and 457 tool leaves. Evaluation on an AppWorld Test-C run set compares TaReD with ADAPT, ReAct, and Plan-and-Solve, alongside tool-awareness ablations and context-exposure analyses. TaReD achieves 69.3% TGC, compared with 51.3% for ReAct and 58.7% for an expandable flat tool subset.

Critical strengths
  1. The paper identifies a useful connection between tool discovery and decomposition granularity. Capability information can help determine executable subtask boundaries rather than merely retrieve tools after a plan has already been formed. This makes the approach practically relevant to agents operating over large API libraries.

  2. The expandable flat-subset ablation is a meaningful control beyond fixed one-shot retrieval. TaReD's 10.6-percentage-point TGC advantage over this condition suggests that the complete hierarchical configuration offers value beyond simply restoring access to omitted tools.

Critical weaknesses
  1. The evidence does not isolate capability-aligned recursion from other changes in the tool interface. Hierarchical nodes provide curated summaries, input/output hints, preconditions, and cross-branch information. Table 2 does not compare against flat access to the same capability-card content, nor does it test non-recursive execution with the same hierarchy. The results therefore support the combined system but do not yet establish that hierarchical guidance improves recursive decomposition specifically.

  2. The reported experiment and runtime policy are not specified precisely enough to assess reproducibility and resource comparability. The "adopted run set" lacks explicit task and scenario denominators, while the accounting of discovery and recursive operations within the 100-step and 600-second limits is unclear. Key decisions such as Sufficient, Direct, and ReviewOrRevise remain underspecified. These omissions affect the interpretation of both success rates and the claimed context-efficiency benefits.

Questions for authors
  1. Clarification of the comparisons. Do the flat and hierarchical conditions receive equivalent semantic information, or do hierarchical capability cards add planning guidance unavailable to the flat conditions? Can you provide existing evidence separating hierarchical tool discovery from recursive execution, or explicitly limit the attribution to their combined effect?

  2. Clarification of the evaluation and implementation. What are the exact task and scenario counts and selection rules for the adopted run set? How are tool discovery, model calls, and recursive operations charged to the step and time budgets? Please also provide the actual decision protocols or prompts for Sufficient, Direct, and ReviewOrRevise, with a real evaluation trace.

3 comments
AuthorsOpenReview ↗

Component Attribution

Dear Reviewer,

Thank you for recognizing TaReD's effectiveness and for your detailed and thoughtful review. We have carefully considered your feedback and clarified the information supplied to each condition, the scope of the performance attribution, and the exact evaluation accounting. Appendix C.2 adds transfer evidence, while Appendix B provides the decision protocols and a real execution trace. We address each point below.

1. Tool information and attribution of the gains

W1: “The evidence does not isolate capability-aligned recursion from other changes in the tool interface. Hierarchical nodes provide curated summaries, input/output hints, preconditions, and cross-branch information. Table 2 does not compare against flat access to the same capability-card content, nor does it test non-recursive execution with the same hierarchy.”

Q1: “Do the flat and hierarchical conditions receive equivalent semantic information, or do hierarchical capability cards add planning guidance unavailable to the flat conditions? Can you provide existing evidence separating hierarchical tool discovery from recursive execution, or explicitly limit the attribution to their combined effect?”

TaReD couples the tool-capability hierarchy with recursive task execution. Starting at the root node of the tool hierarchy, the agent discovers progressively finer functional categories through intermediate nodes. Their capability summaries can establish useful functional stages and dependencies before the agent inspects individual tool leaves. The agent can therefore decompose a goal into functional stages, then refine each subtask through further discovery and recursive execution, retrieving exact tool contracts when execution requires them. This coupling is a central design principle of TaReD: intermediate capability semantics guide the structure and granularity of recursive tasks, instead of requiring task boundaries to be inferred solely from individual APIs (Section 4; Appendices A.2–A.3 and B.2).

Both hierarchical and flat representations are built from the same tool library; shared exposed APIs have identical descriptions and execution contracts. The hierarchy adds intermediate nodes with functional summaries that explicitly support planning at different levels of abstraction. These category-level summaries are part of the design for guiding recursive decomposition. Appending the same summaries to an unordered flat context would retain their text, but would not by itself reproduce hierarchical navigation and its coupling to recursive task decomposition. Exposing all summaries at once could also increase context load and introduce irrelevant planning cues.

In the tool-awareness ablations (Table 2), we compare TaReD with full tool injection and an expandable tool subset under the same recursive execution framework. Full tool injection presents short descriptions of all tools as a flat list and selectively retrieves detailed tool information on demand. The expandable tool subset starts with detailed information for a predicted subset of relevant tools and allows missing tools to be discovered and added during execution. Like TaReD, both conditions can access descriptions and execution contracts across the entire tool library; they differ in how that information is organized and discovered. These results support the combined design of hierarchical representation, capability guidance, and discovery within recursive execution.

MethodTGCSGCATVS
Full tool injection52.00%22.00%71.81
Expandable tool subset58.67%42.00%77.78
TaReD69.33%48.00%80.28

As discussed above, TaReD is designed to realize the full benefit of its tool hierarchy through recursive execution guided by hierarchical tool discovery. Nevertheless, in response to your request, we also evaluated the hierarchy in a non-recursive execution framework. Appendix C.2, Table 4, provides complementary transfer evidence. CUGA uses a fixed hierarchy of application-level planning, API selection through an LLM-based shortlister, and code planning and execution (Appendix C.1). CUGA-Tree retains CUGA's fixed, non-recursive execution framework and replaces its flat tool shortlister with navigation through the capability tree within each selected application. Within CUGA's fixed, non-recursive framework, the transferred design improves all three measures, extending the utility of hierarchical tool discovery beyond TaReD. The transfer results are summarized below:

MethodTGCSGCATVS
CUGA46.67%22.00%61.09
CUGA-Tree54.67%34.00%66.32
AuthorsOpenReview ↗

Evaluation Protocol, Decision Mechanisms

2. Evaluation tasks and cost accounting

W2: “The "adopted run set" lacks explicit task and scenario denominators, while the accounting of discovery and recursive operations within the 100-step and 600-second limits is unclear.”

Q2 (tasks and budgets): “What are the exact task and scenario counts and selection rules for the adopted run set? How are tool discovery, model calls, and recursive operations charged to the step and time budgets?”

We selected 50 scenarios from AppWorld Test-C, with three official variants per scenario, yielding 150 task instances. Appendix E, Table 9, lists all task IDs grouped by scenario. TGC uses all 150 instances, while SGC uses all 50 scenarios and requires success on every variant.

Appendix D summarizes mean per-task costs over all adopted runs, including failures and timeouts. D.1, Table 7 and Figure 4, reports task success alongside model calls, API attempts, and duration; D.2, Table 8, reports cumulative model tokens. The metrics use the following definitions:

  • LLM calls: logical model requests for tool selection, planning, execution, and review, excluding transport retries.
  • API calls: native application API attempts, including authentication, completion, and failed attempts; documentation lookups are excluded.
  • Time: recorded elapsed task-execution time in seconds, including model inference and tool execution.
  • Input/Output tokens: cumulative provider-reported tokens supplied to/generated by the model across a task's calls, reported in thousands. Repeated context counts on every request; Total is their sum.

The statistics cover the main baselines, tool-awareness ablations, and supplementary conditions, including CUGA, CUGA-Tree, and both TaReD tool trees. They show that TaReD gains completion at additional inference cost relative to simpler systems, while combining higher completion with shorter recorded durations than the CUGA systems. Its token cost is concentrated on the input side. These task-level statistics complement Figure 3's average tool-context tokens per saved decision.

3. Actual decision protocols and a real trace

W2 (decision functions): “Key decisions such as Sufficient, Direct, and ReviewOrRevise remain underspecified.”

Q2 (protocols and trace): “Please also provide the actual decision protocols or prompts for Sufficient, Direct, and ReviewOrRevise, with a real evaluation trace.”

TaReD uses a shared decision loop at the root and each child task (Appendix B.1). Given the goal, constraints, dependencies, discovered capabilities, and execution evidence, the model selects the next action. The controller checks and applies it, then returns feedback. The following judgments operate within this loop; Appendix B.2 provides their detailed protocols.

  • Sufficient: after discovery, determine whether capability information supports a plan with identifiable functional parts, outputs, and dependencies. Planning proceeds when these are clear; relevant gaps trigger further discovery. Exact tool schemas can be retrieved later.
  • Direct: once information is sufficient, choose between executing a known sequence of related calls and computations as one stage, or delegating cohesive parts that need separate discovery or judgment to dependent child tasks. Missing schemas alone do not require decomposition.
  • ReviewOrRevise: after a child failure, a review request, or pending work with no ready child, compare returned evidence with the remaining goal and dependencies. Keep a suitable plan or revise its unfinished work, reusing completed results. Failed obligations require explicit links to completed replacements before closure. Return the updated plan and continue, or stop as insufficient if no supported continuation exists.

Appendix B.3 follows adopted Test-C task eb5ad85_1, asking for year-to-date Amazon spending. Over 19 model decisions, TaReD separates order collection from aggregation, passes the collected records by reference, repairs a failed calculation that used the wrong amount field, and resolves the failed child before answering. The result passes both official checks. This trace connects the decision protocols to actual discovery, delegation, data handoff, and recovery.

We have prepared a code repository containing TaReD's detailed implementation. To preserve anonymity during review, we are not including the repository link here. If the paper is accepted, we will provide the link in the final version.

Thank you again for your thoughtful feedback and the effort you have devoted to reviewing our work. We welcome the opportunity to discuss any remaining questions. If you find that our responses and additional results have addressed your concerns, we would be grateful if you could consider a more favorable assessment of our work.

Dear Reviewer,

Thank you again for your time and thoughtful feedback. We would like to follow up on our response and ask whether you have any remaining questions or concerns. We welcome further discussion and would be glad to provide any additional clarification.

If our response and additional results have addressed your concerns, we would be grateful if you could consider a more favorable score in light of this evidence.

Thank you for your consideration.

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

This paper proposes TaReD, which organizes a large tool library into a capability hierarchy and uses on-demand tool discovery to guide recursive task decomposition. It delays detailed tool-contract binding until execution. On AppWorld Test-C, TaReD reports 69.3% Task Goal Completion, outperforming the evaluated ADAPT, ReAct, and Plan-and-Solve baselines.

Critical strengths
  1. The method integrates tool discovery with task decomposition, addressing the limitations of exposing a large flat tool list.
  2. The ablation study compares hierarchical discovery with fixed subsets, full tool injection, and expandable subsets, providing useful evidence for on-demand hierarchical tool access.
Critical weaknesses
  1. The capability hierarchy is largely static and taxonomy-dependent. A tool is assigned one primary category, but real operations can serve multiple functions. Incorrect or overly coarse category boundaries may misguide decomposition, and the paper does not establish robustness to alternative hierarchies.
  2. Recursive depth-first execution introduces additional navigation and planning steps, while decomposition and dependency judgments rely on the model. Errors in these judgments may propagate through the task tree. The paper acknowledges discovery overhead but does not sufficiently quantify the trade-off between success rate, model calls, latency, and context usage.
Questions for authors
  1. How sensitive is TaReD to errors or alternative designs in the manually curated capability taxonomy?
  2. What are the additional model-call and latency costs compared with the baselines, and do the success gains persist under a matched inference-time budget?
3 comments
AuthorsOpenReview ↗

Taxonomy Sensitivity

Dear Reviewer,

Thank you for your thoughtful comments on taxonomy sensitivity, error propagation, and execution costs. We have carefully considered your feedback and added experiments and analyses to address these concerns: Appendix C.3 tests alternative and misleading tool categories, Appendix B explains the execution and recovery protocols with a real trace, and Appendix D quantifies the performance–cost trade-off.

1. Sensitivity to taxonomy design and classification errors

W1: “Incorrect or overly coarse category boundaries may misguide decomposition, and the paper does not establish robustness to alternative hierarchies.”

Q1: “How sensitive is TaReD to errors or alternative designs in the manually curated capability taxonomy?”

We tested a separately generated and reviewed DeepSeek tree built from the same API documentation, preserving all API leaves and contracts. The results support TaReD's robustness to this alternative hierarchy, with strong task performance retained after replacing the tool organization. The GPT tree is used in the main paper; the DeepSeek tree is a supplementary condition with a shallower, application-first organization. Both execute the same Test-C tasks with GPT-5.6 Luna. Appendix C.3, Table 5, reports the comparison:

TaReD tool treeTask success (TGC)Scenario success (SGC)ATVS
GPT tree69.33%48.00%80.28
DeepSeek tree71.33%44.00%83.53

TGC measures complete task success; SGC requires success on every variant of a scenario; ATVS is the mean verifier pass fraction on a 0–100 scale. The alternative tree maintains strong task performance with fewer model and API calls, while scenario-level consistency is slightly lower. This supports effective execution with a substantially different reviewed hierarchy.

To test classification errors, we moved one or two relevant tools into misleading categories for each of ten tasks selected from successful runs. Appendix C.3, Table 6, compares these runs with their historical normal-tree controls:

Tool placementTask successLLM callsTime (s)
Normal tree (historical controls)10/1027.00111.03
With misclassification2/1069.30314.78

Placing tools in misleading categories disrupts the intended alignment between category semantics and tool capabilities, impairing task execution. In this targeted test, agents often fail to find required tools and incur additional model calls and execution time; successful runs encounter the misplaced tools during authentication-related exploration. Semantic review against the source API documentation offers an easy way to detect and correct such mismatches during tree construction, without changing TaReD's execution framework. The unperturbed tool hierarchies used in our TaReD experiments were AI-generated without manual revision, which demonstrates that classification errors in the tool hierarchy will not become a bottleneck for TaReD.

AuthorsOpenReview ↗

Error Recovery, Execution Costs

2. Decomposition errors and recovery

W2 (error propagation): “Recursive depth-first execution introduces additional navigation and planning steps, while decomposition and dependency judgments rely on the model. Errors in these judgments may propagate through the task tree.”

TaReD includes an error-recovery mechanism that helps prevent failures from propagating through the recursive task tree. When a child fails, its status, error feedback, and available outputs return to the parent. The parent reviews this evidence against the goal and dependencies, then revises unfinished work or creates replacement tasks while reusing completed results. Execution resumes under the revised plan; a failed task is resolved by explicitly linking it to a completed replacement. The parent then checks whether the combined results satisfy its goal, and the controller blocks completion while child obligations remain unresolved. If no supported continuation exists, the task returns an insufficient status rather than declaring completion (Appendix B.1–B.2).

The real trace in Appendix B.3 shows this recovery process: a calculation expects the wrong field in a child's output, the parent creates a corrected replacement using the existing data, and the failed obligation is explicitly resolved before completion. The result passes both official checks. Controller checks enforce execution structure, while the model still judges whether the plan and replacement satisfy the goal; final task success is assessed by the official verifier.

3. Performance–cost trade-off and inference-time budgets

W2 (cost trade-off): “The paper acknowledges discovery overhead but does not sufficiently quantify the trade-off between success rate, model calls, latency, and context usage.”

Q2: “What are the additional model-call and latency costs compared with the baselines, and do the success gains persist under a matched inference-time budget?”

Appendix D.1, Table 7 and Figure 4, reports success, logical model calls, native API attempts, and recorded duration. Appendix D.2, Table 8, reports cumulative model tokens, complementing Figure 3's per-decision tool-context measure. The two TaReD rows use the tool trees compared in Section 1 above, with Luna as the execution model in both. All methods use the same standard per-task time budget of 600 seconds.

MethodTask successLLM callsAPI callsTime (s)Input tokens (k)Output tokens (k)
TaReD (GPT tree)69.33%48.5924.25195.78630.5213.07
TaReD (DeepSeek tree)71.33%38.3722.41172.00518.5510.68
ADAPT46.67%19.0513.1777.82396.173.82
ReAct51.33%8.9754.0739.33318.381.58
Plan-and-Solve29.33%29.93113.83108.62451.644.82
CUGA46.67%41.99390.05260.76278.8621.06

Relative to the original GPT-tree version, the DeepSeek tree reduces model calls, duration, and token consumption while retaining higher task success than the baselines shown. Both TaReD variants incur more calls and time than simpler systems, but achieve substantially higher completion; compared with CUGA, which also uses hierarchical planning and execution, both improve success with fewer native API attempts and shorter recorded durations. Both variants use more input tokens but fewer output tokens than CUGA. As discussed in Appendix D.2, more selective retention and compaction of task context could further reduce this input-token overhead.

Thank you again for your thoughtful feedback and the effort you have devoted to reviewing our work. We welcome the opportunity to discuss any remaining questions. If you find that our responses and additional results have addressed your concerns, we would be grateful if you could consider a more favorable assessment of our work.

Dear Reviewer,

Thank you again for your time and thoughtful feedback. We would like to follow up on our response and ask whether you have any remaining questions or concerns. We welcome further discussion and would be glad to provide any additional clarification.

If our response and additional results have addressed your concerns, we would be grateful if you could consider a more favorable score in light of this evidence.

Thank you for your consideration.

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

TaReD is a framework for long-horizon tool-use tasks that couples on-demand navigation of a hierarchical tool library with recursive task decomposition. Capability summaries guide the formation of subtasks, while detailed tool contracts are inspected and arguments bound when a stage is ready to execute. Intermediate results are stored by reference to support dependencies between stages. The paper evaluates the framework on AppWorld Test-C, compares it with ADAPT, ReAct, and Plan-and-Solve, and studies four tool-awareness configurations within the same recursive execution framework.

Critical strengths

A coherent approach to planning with large tool libraries. The framework connects tool discovery to task decomposition, allowing capability information to inform subtask boundaries before exact tool contracts are needed. Delayed contract binding and reference-based result handoffs provide a concrete execution mechanism for dependent subtasks. This is a useful systems contribution for agents operating over large API catalogs, where both tool availability and intermediate state matter.

Critical weaknesses
  1. The additional benefit over related hierarchical agent systems is not sufficiently established. The contribution is primarily a systems integration, which makes comparison with closely related frameworks particularly important. CUGA already combines hierarchical planning and execution, subtask-specific API selection, and intermediate-variable management, and has been evaluated on AppWorld. The current baselines and internal ablations support TaReD's effectiveness, but leave its advantage over this relevant existing system unclear. A comparison under a common backbone and matched budgets would strengthen the positioning of the contribution. See Shlomov et al. (2025), CUGA.

  2. The evidence for broader applicability and the overall cost trade-off is limited. The evaluation uses one backbone on AppWorld Test-C, so the extent to which the gains generalize to other models or interaction environments, such as AndroidWorld, remains uncertain. Moreover, Figure 3 reports average tool-context tokens per saved decision, rather than cumulative model tokens, model-call counts, or task execution time. Section 6 appropriately acknowledges that hierarchical discovery can introduce additional calls and latency, but this trade-off is not quantified. These limitations narrow the scope of the empirical conclusions and leave the practical balance between task success and total cost unresolved. See Rawles et al. (2025), AndroidWorld.

Questions for authors

Could the authors compare TaReD with CUGA on the same AppWorld Test-C tasks, using the same backbone and matched evaluation budgets? This would help establish the additional benefit over an existing hierarchical agent system.

4 comments
AuthorsOpenReview ↗

CUGA Comparison, Hierarchy Transfer

Dear Reviewer,

Thank you for recognizing TaReD's effectiveness and for your detailed and thoughtful review. We have carefully considered your feedback and conducted additional experiments to further validate TaReD's effectiveness and address your concerns and questions. To address the concern that "the additional benefit over related hierarchical agent systems is not sufficiently established," we added a direct comparison with CUGA (Appendix C.1). In response to the observation that "the practical balance between task success and total cost" remains unresolved, we added task-level cost statistics (Appendix D). We also tested the effectiveness of transferring TaReD's proposed tool hierarchy to CUGA's non-recursive execution framework (Appendix C.2).

1. Comparison with CUGA

W1: “The additional benefit over related hierarchical agent systems is not sufficiently established.”

Q1: “Could the authors compare TaReD with CUGA on the same AppWorld Test-C tasks, using the same backbone and matched evaluation budgets?”

TaReD couples a static hierarchy of tool capabilities with a dynamic recursive task tree: discovered capabilities guide subtask boundaries, and returned execution evidence guides subsequent decomposition and revision. The evaluated CUGA system organizes planning and execution into fixed architectural levels. This distinction motivates a direct system-level comparison.

We evaluated the official CUGA implementation on the same AppWorld Test-C tasks as TaReD, using GPT-5.6 Luna for both and a standard per-task allowance of 600 seconds. TaReD improves task success from 46.67% to 69.33% and scenario-level success from 22.00% to 48.00%, supporting stronger completion and consistency across task variants. Appendix C.1 and Table 3 provide the setup and full results.

MethodTask success (TGC)Scenario success (SGC)ATVS
CUGA46.67%22.00%61.09
TaReD69.33%48.00%80.28

TGC measures complete task success; SGC requires success on all variants of a scenario; ATVS is the mean verifier pass fraction on a 0–100 scale.

2. Transferability of the tool hierarchy

To test the transferability of TaReD's tool hierarchy, we constructed CUGA-Tree by retaining CUGA's fixed, non-recursive planning and execution framework and replacing its flat tool shortlister with our hierarchical tool discovery, as described in Appendix C.2. On the same task cohort, task success increases from 46.67% to 54.67% (Table 4). These results show that integrating TaReD's hierarchical tool discovery can improve performance within a non-recursive framework such as CUGA, extending its utility beyond the recursive execution framework it was designed to guide.

MethodTask success (TGC)Scenario success (SGC)ATVS
CUGA46.67%22.00%61.09
CUGA-Tree54.67%34.00%66.32
AuthorsOpenReview ↗

Performance–Cost Trade-off

3. Performance–cost trade-off

W2 (cost trade-off): “Moreover, Figure 3 reports average tool-context tokens per saved decision, rather than cumulative model tokens, model-call counts, or task execution time. Section 6 appropriately acknowledges that hierarchical discovery can introduce additional calls and latency, but this trade-off is not quantified.”

Figure 3 reports average tool-context tokens per saved decision. Appendix D now reports cumulative model usage and task-level execution costs: D.1, Table 7 and Figure 4, cover success, model calls, native API attempts, and duration; D.2, Table 8, separates cumulative input and output tokens.

MethodTask successLLM callsAPI callsRecorded duration (s)Input tokens (k)Output tokens (k)
TaReD (GPT tree)69.33%48.5924.25195.78630.5213.07
TaReD (DeepSeek tree)71.33%38.3722.41172.00518.5510.68
ADAPT46.67%19.0513.1777.82396.173.82
ReAct51.33%8.9754.0739.33318.381.58
Plan-and-Solve29.33%29.93113.83108.62451.644.82
CUGA46.67%41.99390.05260.76278.8621.06

TaReD (GPT tree) uses the GPT-generated tool hierarchy reported in the main paper; TaReD (DeepSeek tree) uses a DeepSeek-generated tool hierarchy evaluated in the supplementary experiments. Both retain the same API leaves and contracts and execute tasks with GPT-5.6 Luna. Appendix C.3 describes the alternative tree and comparison; Appendices D.1–D.2 report their execution and token costs.

These results quantify the trade-off: TaReD uses more model calls and time than lightweight baselines while achieving higher completion. Compared with CUGA, both variants achieve higher task success while using substantially fewer native API attempts and recording shorter task durations. Both have higher cumulative input-token usage and lower output-token usage than CUGA. Appendix D.2 identifies more selective context retention and compaction as a direction for reducing this input cost.

Thank you again for your thoughtful feedback and the effort you have devoted to reviewing our work. We welcome the opportunity to discuss any remaining questions. If you find that our responses and additional results have addressed your concerns, we would be grateful if you could consider a more favorable assessment of our work.

Dear Reviewer,

Thank you again for your time and thoughtful feedback. We would like to follow up on our response and ask whether you have any remaining questions or concerns. We welcome further discussion and would be glad to provide any additional clarification.

If our response and additional results have addressed your concerns, we would be grateful if you could consider a more favorable score in light of this evidence.

Thank you for your consideration.

I will remain my score.

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

Related papers

Loading the map…

Discussion (0)

Sign in to comment.