acceptodds
Under review as a conference paper at ICLR 2027

ODFuse: Observation-Dependency-Guided Step Fusion for Efficient Tool-Use Agents

Abstract

A multi-step tool-use LLM agent must end a step before any operation with an observation dependency: it cannot determine how it uses an intermediate result until it observes that result. Existing agents such as vanilla CodeAct satisfy this dependency only implicitly: they stop after every short block of code and pay for a new round of model reasoning at every stop. Fusing regardless removes those stops, but the agent then acts on evidence it has not seen. We introduce ODFuse, a prompt-only extension of CodeAct agents that constructs each execution step according to observation dependency: it fuses observation-resolved operations and defers unresolved ones until their required evidence has been observed. On two popular tool-use benchmarks (AppWorld and MCP-Universe) with four backbones, ODFuse takes 27–78% fewer steps than vanilla CodeAct, which cuts per-task cost by up to 50% in most settings at a limited loss of accuracy. It also commits 95% fewer over-fusions than an agent that fuses regardless, on the benchmark where that agent errs most.

Primary area:
foundation or frontier models, including LLMs
Keywords:
LLM agents, tool use, ReAct, CodeAct, inference efficiency, token cost, agent scaffolding

Reviews

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

This work investigates the efficiency and effectiveness of tool use in LLM agents, focusing on two issues: over-fusion and under-fusion. Over-fusion occurs when an agent combines tool operations without respecting observation dependencies, potentially leading to incorrect behavior. In contrast, under-fusion occurs when an agent executes independent operations in separate steps, resulting in unnecessary tool calls and increased costs. To address these issues, the authors propose ODFuse, a prompt-based extension of CodeAct that introduces a two-phase tool-calling strategy. The first phase selects operations that can be executed together based on their observation dependencies, while the second phase determines which intermediate results need to be observed before subsequent execution steps. Experimental results on AppWorld and MCP-Universe demonstrate the effectiveness of the proposed method in reducing execution steps and costs while maintaining competitive task performance.

Critical strengths
  1. Interesting research problem. The paper addresses the over-fusion and under-fusion issues in tool calling, which are interesting and relevant to the development of LLM agents. Properly organizing tool invocations is important for improving both the effectiveness and efficiency of agent execution.
  2. Promising experimental results. The experimental results on two benchmarks, AppWorld and MCP-Universe, provide strong empirical support for the effectiveness of the proposed method. Compared with the baselines, the proposed approach generally achieves competitive or better task performance while reducing execution costs.
Critical weaknesses
  1. Limited generalizability of the identified issues. Although the identified problems are interesting, the current findings are primarily based on relatively older models, such as Gemini 2.5 and GPT-5. It remains unclear whether these issues are equally prevalent in more recent models, particularly those that have undergone specialized post-training for tool use. Additionally, both evaluated benchmarks involve tool-intensive tasks, which may limit the generalizability of the identified issues to other agentic scenarios.

  2. Unclear distinction between the proposed method and reasoning-based improvements. The underlying idea of the two-phase prompting strategy appears to be a form of explicit reasoning guidance, which encourages the model to perform additional reasoning before executing tool calls. Therefore, the observed improvements may primarily result from enhanced reasoning and contextual understanding rather than the proposed two-phase prompting mechanism itself. Given that reasoning capabilities are already widely incorporated into modern agent designs, this raises concerns about the novelty and practical applicability of the proposed approach.

Questions for authors
  1. Are the identified over-fusion and under-fusion issues still prevalent in more recent LLMs, particularly when using their native tool-calling interfaces and templates?
  2. What is the impact of reasoning on the identified issues and the proposed method? For example, would enabling reasoning with a low reasoning effort produce similar improvements? Does ODFuse remain effective when applied to agents with explicit reasoning capabilities?
  3. To what extent do the findings generalize to other agent benchmarks, such as ALFWorld or ClawMark, which may involve different tool-use patterns and task characteristics?
Reviewer_ZUf5OpenReview ↗
Rating
2
Confidence
3
Informativeness
2
Presentation
2
Soundness
2
Read review
Paper summary

This paper proposes ODFuse, a prompt-only approach to improving the efficiency of CodeAct-based tool-use agents. The central idea is to use observation dependency as the criterion for constructing execution steps: operations whose required information is already available can be fused into the current step, whereas operations that require inspecting intermediate results are deferred. The method further employs an eager-ready fusion procedure to include ready operations and fetch observations needed by deferred operations. The authors evaluate ODFuse on AppWorld and MCP-Universe using four language model backbones. The results show that ODFuse reduces the number of steps by 27–78% compared with vanilla CodeAct across 24 configurations, while reducing per-task cost in most settings and generally maintaining comparable task performance. The paper also introduces a fusion detector to analyze under-fusion and over-fusion, and compares ODFuse against several training-free efficiency baselines.

Critical strengths
  1. The paper addresses a practical and important problem. Tool-use agents often invoke the model repeatedly even when subsequent operations can be determined without inspecting new observations. Reducing unnecessary reasoning rounds is a useful direction for improving agent efficiency.
  2. The proposed method is simple and easy to deploy. ODFuse requires only prompt-level modifications to an existing CodeAct loop, without additional model calls, a separately trained planner, or an external verification module. This makes the approach potentially attractive for practical applications.
Critical weaknesses
  1. The core concept of ODFuse is to leverage "observation dependencies" to determine which tool-calling operations can be merged into a single step and which must be deferred until intermediate observations are obtained. However, the paper fails to clearly articulate how this approach differs—conceptually and technically—from existing methods in "dependency-aware planning," "tool-call batching," and "execution scheduling." As currently presented, ODFuse appears to rely primarily on prompt-level instructions to guide step merging; this makes it difficult to discern whether the method represents a substantive methodological innovation or merely a practical heuristic strategy. The authors should more explicitly define the innovative aspects of ODFuse and provide a clearer comparison with the most relevant prior research.
  2. ODFuse relies on observation dependencies to distinguish between "operations that can be safely merged" and "operations that require intermediate results." Yet, the paper does not sufficiently substantiate the reliability of identifying these dependencies—which, in complex tasks, are often implicit or difficult to infer accurately from the existing context. Furthermore, the merging analysis employs a detection mechanism that utilizes an LLM-based discriminator, the reliability of which has not been adequately validated. Errors in dependency identification could lead to "over-merging" (causing execution failures) or "under-merging" (diminishing the claimed efficiency gains).
  3. While ODFuse does reduce the number of execution steps, its impact on task accuracy varies depending on the model and the task domain; in some configurations, it even results in a notable performance degradation. Moreover, the evaluation is limited to CodeAct-based agents and excludes "web search" and "browser automation" scenarios from the MCP-Universe benchmark, which restricts the evidence for the method's applicability to a broader range of tool-use scenarios. Although the paper includes some cost analysis, the primary evaluation is conducted under the assumption of an "idealized prompt-cache." The authors should more clearly articulate the trade-off between efficiency and task success rate, emphasize cost metrics based on real-world scenarios, and provide further evidence demonstrating that the proposed method can generalize to environments beyond those evaluated.
Questions for authors
  1. How often does ODFuse incorrectly classify an operation as ready when the decision actually requires inspecting an intermediate result? Can this be measured independently of the task completion score?
  2. Can the proposed instruction generalize to tool-use frameworks other than CodeAct without requiring substantial prompt or runtime modifications?
  3. How reliable is the fusion detector, particularly its LLM-judged cases, and how sensitive are the reported over-fusion and under-fusion rates to the detector's design?
Reviewer_JjmfOpenReview ↗
Rating
2
Confidence
3
Informativeness
2
Presentation
2
Soundness
2
Read review
Paper summary

The paper defines observation dependency. An operation has this dependency when the model must read an earlier result before it can write the operation. ODFuse is a prompt for CodeAct agents. The prompt puts every ready operation into one step, together with the lookups that deferred operations need. It also prints the values that the next step must read. The authors test ODFuse on AppWorld and four MCP-Universe domains with four backbones. ODFuse uses 27 to 78% fewer steps and decreases cost in 22 of 24 configurations, with an accuracy loss of 5 pp or less. A rule-based detector with an LLM judge counts over-fusions and under-fusions to support the causal claim.

Critical strengths
  1. The step and cost reduction is consistent. ODFuse decreases steps in all 24 configurations across proprietary and open-weight backbones, and the cost result holds under three billing regimes. Nine seeds on Gemma-4-31B show a significant accuracy loss on one task set, at 1.29 pp. This consistency makes ODFuse a cheap and practical default for CodeAct agents.

  2. The AggFuse and one-line ablations isolate the step boundary decision. AggFuse falls to 13.5 to 37.9 TGC on AppWorld. The one-line rule loses 8 to 12 pp on AppWorld and Financial Analysis. These results show that the place where a step ends controls accuracy, and that the number of fused operations does not.

Critical weaknesses
  1. The vanilla baseline is weak because of its prompt. The prompt tells the model to write small chunks and one chunk per step, which forces under-fusion. The paper does not test CodeAct with a neutral step policy. Without this control, the savings and the large gains (+24.2 pp on Qwen3.6-27B AppWorld Challenge) can come from the removal of a bad instruction or from fewer step-limit and context failures. They need not come from the observation-dependency.

  2. The mechanism evidence is circular and has no external validation. The detector rules encode the same criterion that the ODFuse prompt states. An LLM judge settles the open cases with no human agreement data, and the detector runs on Gemini-2.5-Pro only. Appendix A.2 shows that over-fusion does not explain the loss on AppWorld Normal, and that ODFuse under-fuses independent searches on Location Navigation. The claim that the criterion governs where steps end therefore lacks independent support.

Questions for authors
  1. What are the steps, cost, and accuracy of CodeAct with no step-size instruction on Gemma-4-31B?

  2. On Qwen3.6-27B AppWorld Challenge, how many vanilla CodeAct failures come from the 40-step limit or the context limit?

  3. What is the agreement between the LLM judge and human annotators on a sample of fusion verdicts?

  4. Why does ODFuse issue the independent Location Navigation searches one per step, when its prompt admits all ready operations?

  5. Do the proprietary-backbone results hold over repeated seeds? One 3D Design task changes AE by about 5 pp.

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

Related papers

Loading the map…

Discussion (0)

Sign in to comment.