acceptodds
Desk rejected at ICLR 2027

RectifyFlow: Plan Upfront, Rectify Selectively for Cost-Efficient Edge–Cloud Tool-Using Agents

Desk rejected at ICLR 2027, so left out of the paper lists and the map.

Abstract

Tool-using agents increasingly rely on cloud LLMs to execute complex multi-step workflows, but repeated LLM calls incur substantial monetary cost. Edge-side small models (SMs) offer a cheaper alternative, yet their weaker reasoning can compromise execution quality. Edge–cloud collaboration therefore promises a better quality–cost trade-off, but existing approaches remain inefficient for tool use: iterative execution triggers frequent cloud interactions, while local decision errors can propagate through dependent operations and cause costly replanning. We propose RectifyFlow, a cost-efficient edge–cloud framework that minimizes cloud involvement while containing edge-side execution errors. First, Dual-View Plan Construction produces structured plans that guide the edge SM through multiple dependent operations with limited cloud intervention, avoiding repeated cloud reasoning during execution. Second, when execution deviates from the plan, Dependency-Aware Plan Rectification identifies the deviation source, traces its downstream impact, and selectively repairs only the affected plan components, rather than regenerating the entire plan. Across BFCL and ToolSandbox, RectifyFlow retains 94.6% and 91.8% of Cloud-only performance while reducing cloud API cost by approximately 2.5 and 2.1, respectively. Against nine representative baselines, RectifyFlow achieves approximately 1.5 higher task performance at 1.3 lower cost, demonstrating a substantially improved quality–cost trade-off for tool-using agents.

Primary area:
infrastructure, software libraries, hardware, systems, etc.
Keywords:
Edge-Cloud Collaboration, Tool-Use Agents, LLMs

Reviews

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

This paper introduces RectifyFlow, an edge–cloud collaboration framework for tool-using agents that aims to significantly reduce cloud API cost while preserving most of the quality of cloud-only execution. The key ideas are Dual-View Plan Construction, which builds a dependency-aware DAG and a linear execution view with explicit output references, grounding specifications, and execution criteria to guide a small edge model, and Dependency-Aware Plan Rectification, which localizes deviations via backward tracing and selectively repairs only affected subgraphs (plus optional state rollbacks). Experiments on BFCL and ToolSandbox show RectifyFlow achieves around 92–95% of cloud-only quality with roughly 2.+× cost reduction and fewer cloud calls than nine representative baselines.

Critical strengths

Clear formulation of a dual-view plan that separates a DAG dependency view (for selective rectification) from a linear execution view (for edge execution), with explicit mechanisms for output binding, argument grounding, and execution criteria. Dependency-aware rectification that performs backward localization to find a deviation source and forward impact analysis to bound the repair scope. The additional separation of plan edits and state-consistency repairs is a practical and well-motivated design for stateful tools. The framework explicitly targets the quality-cost frontier in tool-use scenarios, bridging plan-and-execute paradigms with edge or cloud collaboration mechanics. Broad comparisons against nine baselines (routing, hybrid planning, and plan-and-execute variants) across two widely used tool-use benchmarks, reporting both quality and cloud cost. Useful systems-level metrics beyond accuracy: latency, P95 latency, RTT, and communication, plus ablations on the two main components (DPC and DPR) and sensitivity to local recovery budgets. Generalization tests across multiple edge models and a second cloud LLM, suggesting the method’s benefits are architecture-agnostic. The pipeline is presented end-to-end with an overview figure, concrete node schema, and high-level pseudocode (Algorithms 1 and 2), making the components and execution flow understandable. The role of the binding map, execution criteria, and local recovery budget is clearly articulated, as is the rectification context passed to the cloud.

Critical weaknesses

The deviation localization and selective rectification steps rely on the cloud LLM’s qualitative reasoning rather than a principled, auditable algorithm; criteria for selecting the “earliest” deviation source are unspecified, which may affect stability and reproducibility. The semantics and feasibility of “state rollback” in state are under-specified. Many real tools have irreversible or non-idempotent effects, and the framework’s behavior in these cases is unclear. Parallelism is not discussed: the linear execution view may limit throughput in scenarios with independent branches, potentially sacrificing efficiency relative to DAG-parallel methods. Missing comparisons to recent dependency-aware planning or repair frameworks like ATG and SPIN that also use DAGs and minimal subgraph repair or validation, which are highly relevant for judging novelty and effectiveness of selective rectification. Limited analysis of failure modes: e.g., how often backward localization misattributes sources, frequency and cost of state rollbacks, and the distribution of rectification rounds. The evaluation relies on BFCL and ToolSandbox. Recent audits show evaluator brittleness and run-to-run variance on such tool-calling benchmarks. Only “mean over three runs” is reported, with no variance or adjudication measures. Some tables/figures appear with minor formatting artifacts and unlabelled axes in the extracted text. More precise numeric reporting for generalization (e.g., GPT-5.6-Terra) would aid interpretation. The sensitivity table mixes budgets awkwardly, and the “w/o Repair” line appears in a different sub-table context. Clearer separation of analyses would help. Beyond the plan-and-execute baselines included (ReWOO, Plan-and-Act), there is no direct experimental comparison to ATG’s minimal subgraph repair and SPIN’s validated DAG interface, both very close in spirit to the selective rectification and structured planning claims here. Recent works on device-cloud orchestration for agents (e.g., EdgeWise) and device-cloud multi-agent planners (e.g., EcoAgent) could be discussed more explicitly to situate the contribution among designs that reduce cloud interactions via planning and on-device verification.

Questions for authors

See weaknesses.

4 comments
AuthorsOpenReview ↗

Response to Reviewer 2NSW

We thank the reviewer for the thoughtful and constructive feedback. Below, we comprehensively address the raised concerns through clarifications and additional experiments, and welcome further discussion. Please note that a recent update to the underlying DeepSeek API yields higher scores in some newly added experiments than those reported in the original manuscript, without changing our main conclusions.

W1. Auditability and Reliability of the RectifyFlow

We thank the reviewer for raising this important concern. RectifyFlow does not rely on unconstrained qualitative reasoning; instead, it adopts an evidence-constrained, graph-based localization procedure, where the LLM interprets execution evidence under explicit DAG constraints.

Specifically, RectifyFlow (1) identifies the interrupted node from runtime feedback, (2) traces its predecessors in the DAG to constrain candidate sources, (3) compares their planned behavior against actual outputs, execution history, and state changes, and (4) selects the earliest evidence-supported erroneous node, i.e., one without an earlier erroneous ancestor. The downstream impact scope is then determined through graph reachability.

The process is auditable: the DAG explicitly records node IDs, typed dependencies, output references, and execution conditions, while runtime bindings, interaction history, and interruption evidence are retained. Structured diagnosis records the identified source, supporting evidence, affected nodes, and rectification operations, making the reasoning process and resulting decisions inspectable.

Table 1. Deviation Source Localization Accuracy

MethodDeviation Source Localization Accuracy
DeepSeek-Flash91.23%
GPT-5.6-Terra90.17%
GPT-6.1-Sol94.43%

Table 2. Rectification Performance of RectifyFlow

MetricRectifyFlow
Deviation Detection Accuracy91.23%
Post-Rectification Accuracy86.52%
Avg. Cumulative Rectification Time (s/task)4.98

To evaluate reliability, we conduct ground-truth-based localization across three cloud models. As shown in Tab. 1, localization accuracy reaches 91.23%, 90.17%, and 94.43%, respectively, demonstrating cross-model robustness. Together with the post-rectification accuracy and rectification-time results reported in Tab. 2, these findings further demonstrate the effectiveness and reliability of RectifyFlow's localization and rectification mechanism.

W2. Clarifying the Semantics and Scope of State Rollback

We thank the reviewer for raising this important concern and prompting us to clarify the semantics of state rollback.

In RectifyFlow, rollback refers to restoring consistency in the states and results affected by executed tool operations. It includes correcting reversible states through compensating tool operations (e.g., toggling feature switches) and invalidating erroneous result bindings followed by re-querying. However, rollback does not imply transactional undo: its applicability depends on tool-specific recovery capabilities. It cannot reverse irreversible actions (e.g., sent emails) or guarantee safe re-execution of non-idempotent operations. We will clarify these semantics in the revised manuscript.

Furthermore, we inspected execution traces involving irreversible operations and found that 9% of evaluated samples involved erroneous irreversible actions. We emphasize that pre-execution safety and RectifyFlow's runtime rectification address two distinct yet complementary problems: the former aims to prevent irreversible actions before execution, whereas RectifyFlow focuses on localizing execution deviations and recovering from them. Recent studies, such as MOSAIC (ICML 2026) and StepGuard (EMNLP 2026), investigate pre-execution safeguards. These mechanisms can be integrated with RectifyFlow to enable safer execution.

AuthorsOpenReview ↗

Response to Reviewer 2NSW

W3. RectifyFlow vs. DAG-Based Parallel Execution

We further compare RectifyFlow with the parallel execution method LLMCompiler (Tab. 3). LLMCompiler achieves lower P95 latency but incurs substantially higher cloud overhead and lower task quality. One possible explanation is that parallel execution allows multiple branches to progress simultaneously, potentially accumulating errors before they are detected. This may require the cloud model to handle multiple errors and their downstream effects concurrently, increasing diagnosis and recovery costs and offsetting much of the expected speedup. Consequently, despite achieving lower P95 latency, LLMCompiler has slightly higher average latency (14.33 vs. 14.08 s/task), while incurring substantially higher cloud overhead and lower task quality. In contrast, RectifyFlow's sequential execution enables deviations to be detected and rectified before further propagation, yielding a more favorable quality–cost trade-off.

Table 3. RectifyFlow vs. LLMCompiler

MethodSimilarity ↑Avg. E2E (s/task) ↓P95 E2E (s/task) ↓Cloud Traffic (MiB/task) ↓API Cost (10−310^{-3} USD/task) ↓
LLMCompiler0.614614.3335.770.06711.519
RectifyFlow0.718814.0842.060.02880.542

W4. Comparison of RectifyFlow with ATG and SPIN

We thank the reviewer for pointing out these relevant works. ATG and SPIN focus on improving agent planning and execution efficiency, whereas RectifyFlow targets cost-efficient edge–cloud collaboration. ATG reduces execution overhead through DAG-based task decomposition, parallel execution, and minimal subgraph repair. SPIN reduces redundant tool execution through DAG validation and simulator–critic-based early stopping.

More importantly, the underlying problem formulations differ. ATG and SPIN primarily model task and tool dependencies within an LLM-agent workflow, without explicitly considering heterogeneous edge–cloud collaboration. In contrast, RectifyFlow coordinates cloud-side planning and rectification with continuous edge-side execution, introducing cross-tier dependencies and interactions among models, tool operations, and execution states. Managing these dependencies while minimizing cloud inference costs is a central focus of our work.

Our initial baseline selection primarily focused on methods targeting edge–cloud collaboration and cost optimization. Nevertheless, given the methodological relevance of ATG and SPIN, we have added direct comparisons on ToolSandbox.

Table 4. RectifyFlow vs. ATG and SPIN

MethodAvg. Perf. ↑Avg. E2E (s/task) ↓P95 E2E (s/task) ↓API Cost (10−310^{-3} USD/task) ↓Traffic (MiB/task) ↓
ATG0.403814.5042.391.9750.0526
SPIN0.526122.4949.942.0570.1004
RectifyFlow0.718814.0842.060.5420.0288

As shown in Tab. 4, RectifyFlow achieves the highest task performance (0.7188) and the lowest overhead across all reported metrics. These results demonstrate the advantage of jointly coordinating cross-tier execution and dependency-aware rectification to optimize task quality and cloud inference cost.

AuthorsOpenReview ↗

Response to Reviewer 2NSW

W5 Analysis of failure modes

We further analyze three aspects of RectifyFlow's failure modes and recovery overhead:

(1) Backward localization errors. As reported in W1, under the DeepSeek-Flash configuration, RectifyFlow achieves 91.23% accuracy in backward deviation localization, corresponding to an 8.77% localization error rate. This indicates that most deviation sources are correctly identified, providing a reliable basis for selective rectification.

(2) State rollback frequency and overhead. On ToolSandbox, state rollback is triggered 0.314 times per task on average, with an average cumulative time of 0.458 s/task. This accounts for 4.23% of average task latency, while its associated API cost accounts for 16.2% of RectifyFlow's average API cost, indicating relatively limited recovery overhead.

(3) Rectification round distribution. Tab. 5 reports the distribution of cloud repair rounds. Specifically, 54.93% of tasks require no repair, 39.41% require one round, and only 5.66% require two or more rounds. Thus, 94.34% of tasks complete with at most one repair round, suggesting that RectifyFlow generally avoids repeated rectification. Table 5. Cloud Repair Round Distribution on ToolSandbox

Repair RoundsPercentage
054.93%
139.41%
25.16%
30.25%
40.25%
≥50.00%

W6. Reliability of the Evaluation

We thank the reviewer for highlighting the reliability of benchmark evaluation. We address this concern from two aspects:

(1) Evaluator reliability. We re-examined the evaluation results against recorded execution traces, achieving 96% evaluation accuracy. We further manually adjudicated discrepant cases and found that disagreements mainly stemmed from hallucinations by the ToolSandbox user-simulator LLM and scoring discrepancies caused by state and field matching in BFCL. After excluding these cases, RectifyFlow's advantages in task quality and overhead remain consistent, indicating that these evaluation discrepancies do not alter our overall conclusions.

(2) Run-to-run stability. Beyond reporting mean performance, we provide the variance across three repeated runs on both benchmarks (Tab. 6). The results show that RectifyFlow maintains reasonably stable performance across runs, with variances of 6.2500 × 10⁻⁴ on BFCL-V4 and 11.0217 × 10⁻⁴ on ToolSandbox, providing additional evidence of evaluation stability.

Table 6. Average Performance and Variance Across Three Runs

MethodBFCL V4 Avg. Perf. ↑ (×10⁻²)BFCL V4 Variance (×10⁻⁴)ToolSandbox Avg. Perf. ↑ (×10⁻²)ToolSandbox Variance (×10⁻⁴)
Cloud-only81.0922.366870.6510.8187
Local-only6.884.409238.2624.2544
MiniCPM5-2B4.383.246738.2016.6288
GAPG45.6314.062559.9522.0897
AIMS37.0313.488153.903.1759
Hera37.0316.590158.7813.6848
DoT16.725.946166.7010.1091
Minions48.4410.259244.5913.3567
HybridFlow53.135.311655.857.7719
RectifyFlow76.726.250064.8311.0217

W7. Figure Formatting and Axis Labels

We thank the reviewer for pointing out these presentation issues. We will correct the formatting artifacts in the relevant tables and figures and ensure that all figure axes are clearly labeled in the revised manuscript.

W8. Detailed Results for GPT-5.6-Terra

We provide detailed results for GPT-5.6-Terra on BFCL-V4 in Tab. 7, reporting both task performance and estimated API costs to enable a more precise comparison across methods. RectifyFlow retains 96.42% of Cloud-only performance while incurring only 62.75% of its API cost, further demonstrating its favorable quality–cost trade-off with GPT-5.6-Terra.

Table 7. performance on BFCL V4 with GPT-5.6-Terra

MethodApprox. Avg. Perf. ↑ (×10−2\times 10^{-2})Est. API Cost ↓ (10−310^{-3} USD/task)vs. Cloud-only (Perf. ↑ / Cost ↓)
Cloud-only82.9735.650100.00% / 100.00%
Local-only5.000.0006.03% / 0.00%
GAPG60.0027.58072.32% / 77.36%
AIMS44.0626.18253.11% / 73.44%
Hera54.0627.12065.16% / 76.07%
DoT29.0629.54435.03% / 82.87%
Minions39.0625.27547.08% / 70.90%
HybridFlow55.9430.55867.42% / 85.72%
RectifyFlow80.0022.37096.42% / 62.75%
AuthorsOpenReview ↗

Response to Reviewer 2NSW

W9. Revision of Table Structure

We thank the reviewer for pointing out the ambiguity in the table organization. We will separate Table 4 into two independent tables: (1) sensitivity analysis on BFCL, reporting performance under different local recovery budgets (0–5), with "w/o Repair" relabeled as "No Local Recovery (Budget = 0)"; and (2) ablation study on ToolSandbox, comparing the full framework with variants without DPC and DPR. This separation clarifies the distinction between recovery-budget sensitivity and component contributions, making the experimental results easier to interpret and compare.

W10. Comparison with ATG, SPIN, EdgeWise, and EcoAgent

We thank the reviewer for highlighting these relevant works. As discussed in W4 (Comparison with ATG and SPIN), ATG and SPIN address different problem formulations and optimization objectives. EdgeWise was released after our submission deadline and primarily evaluates cloud delegation on coding and terminal-agent benchmarks. EcoAgent targets mobile GUI automation, where execution relies on screen observations and UI interactions, with efficiency gains primarily achieved through on-device verification and compressed visual feedback.

Although EcoAgent also optimizes the quality–cost trade-off in device–cloud collaboration, its task setting and primary sources of overhead differ from ours. RectifyFlow focuses on stateful API-based tool use, where structured tool outputs and state changes create interdependent operations, and errors may propagate to downstream steps, incurring additional cloud recovery costs. EcoAgent is not specifically designed or evaluated for this dependency-driven recovery setting, which informed our initial baseline selection. Nevertheless, we acknowledge the relevance of these works and have added direct comparisons with all four methods on ToolSandbox.

Table 8. RectifyFlow vs. All Baselines on ToolSandbox

MethodAvg. Perf. ↑Avg. E2E (s/task) ↓P95 E2E (s/task) ↓API Cost (10−310^{-3} USD/task) ↓Traffic (MiB/task) ↓
ATG0.403814.5042.391.9750.0526
SPIN0.526122.4949.942.0570.1004
EdgeWise0.478221.3656.310.9690.0605
EcoAgent0.519839.7991.761.4450.0323
RectifyFlow0.718814.0842.060.5420.0288

As shown in Tab. 8, RectifyFlow achieves the highest task performance (0.7188) and the lowest API cost (0.542 × 10⁻³ USD/task), latency (14.08 s/task) among the compared methods, demonstrating its effectiveness in jointly maintaining execution quality and controlling cloud recovery overhead.

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

This paper proposes RectifyFlow, an edge–cloud framework for tool-using agents. The cloud LLM constructs a dual-view plan. The dependency view records relationships between operations. The execution view provides output references, argument-grounding instructions, and execution criteria. These guide the local small model through multiple steps. When execution deviates from the plan, the cloud LLM identifies the source, analyzes its downstream impact, and selectively repairs the plan while preserving valid execution results.

The authors compare RectifyFlow with several collaboration and planning methods on BFCL and ToolSandbox. RectifyFlow keeps about 93% of Cloud-only performance and reduces API costs by about 56%.They also evaluate different models, conduct component ablations, and analyze system overhead.

Critical strengths
  1. The method has a clear design. The execution view guides the small model in constructing tool arguments and deciding when to execute each step. The dependency view helps the cloud model locate deviations and identify affected steps for selective repair. Together, the dual-view plan supports reliable execution and preserves valid results during recovery.
  2. The performance and cost benefits have clear experimental support. The authors compare against several collaboration and planning baselines. On BFCL and ToolSandbox, the method retains about 94.6% and 91.8% of Cloud-only performance and reduces API costs by about 60.6% and 51.4%. The ablations also support the effectiveness of the core mechanisms. These cost benefits are the main reason I lean toward acceptance.

Overall, the paper presents a reasonable design and fairly comprehensive experiments. The novelty mainly lies in improvements to the framework. I lean toward weak acceptance.

Critical weaknesses

None

Questions for authors
  1. Are cloud API costs calculated using separate input token prices for cache hits and misses for each method? If caching is not considered, would cache discounts change the cost differences and rankings across methods?
  2. When a new user message arrives in a multi-turn interaction, does RectifyFlow call the cloud LLM to generate a new plan, or reuse and update the existing plan? What share of the total cloud calls and API costs comes from handling these new messages?
3 comments
AuthorsOpenReview ↗

Response to Reviewer kqpr

We sincerely thank the reviewer for the thoughtful and encouraging feedback, as well as the valuable suggestions. We have carefully addressed the concerns through further clarifications and additional analyses, as detailed below, and welcome further discussion.

Q1. Cache-Aware API Cost Evaluation

We thank the reviewer for raising this concern. To explicitly account for caching, we recalculated the cloud API costs of all methods using separate prices for cache-hit input tokens, cache-miss input tokens, and output tokens, based on token usage reported by the API.

The cache-aware API cost per task is calculated as:

Costtask(10−3USD)=10−3(phitH+pmissM+poutO)Cost_{task}(10^{-3} USD) = 10^{-3} (p_{hit}H+p_{miss}M+p_{out}O)

For a single task, HH, MM, and OO denote the numbers of cache-hit input tokens, cache-miss input tokens, and output tokens, respectively. The corresponding prices, expressed in USD per million tokens, are phitp_{\mathrm{hit}}, pmissp_{\mathrm{miss}}, and poutp_{\mathrm{out}}.

Table 1. Cloud API Costs with Separate Cache-Hit and Cache-Miss Pricing on ToolSandbox

MetricCloud-onlyLocal-onlyGAPGAIMSMinionsHeraDoTHybridFlowRectifyFlow
API Cost (10−310^{-3} USD/task) ↓1.3870.0000.8030.5761.0090.9301.0540.8360.446

As shown in Tab. 1, accounting for cache discounts changes some relative cost rankings but does not weaken our main conclusions. RectifyFlow achieves the lowest API cost among cloud-using methods, reducing expenditure by 67.84% compared with Cloud-only and 22.57% compared with the next most cost-efficient baseline (AIMS). These results further substantiate RectifyFlow's cost advantage under cache-aware pricing.

Q2. Handling of New User Messages and Overhead Analysis

We thank the reviewer for raising this question. RectifyFlow handles new user messages in two cases:

(1) Plan reuse. For follow-up messages within an ongoing task, RectifyFlow prioritizes reusing the existing plan and updates it when necessary, avoiding unnecessary replanning.

(2) New planning. When no reusable plan is available, RectifyFlow invokes the cloud LLM to construct a new execution plan.

We evaluate both cases using ToolSandbox's built-in user-message simulator. 92.90% of new-message requests reuse existing plans. As shown in Tab. 2, handling new messages incurs an average of 0.415 cloud calls and 0.277 × 10⁻³ USD per task, accounting for 15.78% of total cloud calls and 19.36% of total API costs, respectively.

Table. 2 Cloud Calls and API Costs for New User Messages on ToolSandbox

Request TypeAvg. Calls (/task)Share of Cloud CallsAvg. API Cost (10⁻³ USD/task)
New messages: reuse the existing plan0.38614.66%0.257
New messages: initial planning without a reusable plan0.0291.12%0.020
All new-message handling0.41515.78%0.277

These results show that RectifyFlow handles most follow-up messages through plan reuse, limiting redundant planning while keeping the additional cloud overhead measurable and controlled.

Thank you for the updated API cost comparison in Table 9. RectifyFlow retains its cost advantage on ToolSandbox with cache discounts. The explanation of follow-up message handling addresses my second question. I will maintain my weak acceptance rating.

AuthorsOpenReview ↗

Sincere Appreciation to Reviewer kqpr

We sincerely thank reviewer kqpr for the thoughtful engagement and positive assessment. We greatly appreciated the timely and constructive exchanges throughout the discussion and are grateful for the continued support and valuable feedback. We will continue to refine and strengthen our work.

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

this paper proposes a edge cloud collaborative framework for reducing the cost of multiple tool-using agents while ideally maintaining task performance. The idea is to combine a powerful "cloud" model with a smaller, local model to realize two main components: i) dual-view plan construction (dpc) where the cloud model generates a DAG for representing the dependencies between operations and a linear execution plan containing the instructions for the edge model , and ii) dependency-aware plan rectification (dpr) which acts when local execution fails or deviates from the plan. here the cloud model has to identify the source of the problem and revise selected operations

this orchestration is evaluated on both BFCL-V4 and ToolSandbox, varying availability scenarios (cloud only, local only , edge-cloud collab). the main results show that the proposed approach is able to retain over 90% of performance on both benchmarks while using between 39% nd 49% of the API cost.

Critical strengths

this paper addresses the "monetary" cost of cloud-based tool-using agents, which is an important obstacle to deploying agents in resource-constrained environments. in that sense the proposed edge–cloud architecture offers an attractive trade-off: using the cloud for high-level planning and complex corrections while delegating routine execution to cheaper local models. while not fundamentally novel, i think it is a good contribution from the practical perspective

the separation between dependency representation and executable instructions is well motivated and it is in my opinion the core contribution, The dependency graph supports reasoning about relationships among operations, while the linear execution view provides step-by-step guidance suitable for a smaller model. from the practical perspective that modularity is desirable we could prioritize and weight based on budget considerations

The selective rectification mechanism is also intuitive: when an execution problem occurs, preserving valid operations should be more efficient than restarting or regenerating the entire workflow. This is specifically suitable for current ai cloud infras

In papers like this, ablation studies are quite important. In this case we can see that the ToolSandbox ablation shows that removing Dual-View Plan Construction reduces performance from 64.83 to 50.60 and increases average cloud calls. This is a very relevant result and can motivate several other improvements. something similar happens when removing the Dependency-Aware Plan Rectification -> it increases API cost and cloud calls, suggesting that selective updates contribute to efficiency.

overall what we can see here is that there is an actual distinction between what we can call improvements in "execution reliability" and. improvements in "correction costs".

Critical weaknesses

as i stated above , in terms of novelty, one could say the central ideas (constructing an execution plan, representing task dependencies, executing locally,etc ) have substantial overlap with existing plan-and-execute and dependency-aware agent frameworks. the authors cite several related works in this line . Now, the specific combination of a dependency graph, linear execution instructions, and selective repair is useful, but I am not fully convinced that it represents a sufficiently novel algorithmic contribution rather than a carefully engineered (and clever) integration of established ideas.

going down a bit more into technical terms, we could say the approach focuses only on cloud api cost, excluding , for example , the cost of the local GPU inference. This comment could sound orthogonal , but, lerts remember that the proposed approach uses an ""edge-side"" model for execution and recovery , then -> local inference consumes computational resources, energy, and hardware capacity. in that sense, the central claim should therefore be interpreted as a reduction in "cloud API expenditure", not necessarily a demonstrated reduction in "total deployment cost" .

now probably the most critical element that in my opinion could be considered as a weak point for a venue like ICLR: reading the paper there is very limited evidence that "dependency aware rectification" actually can identify correct causal dependencies . Why i consider this as a weak point ? we know the paper implements a kind of. backward deviation localization (basically just trying to locate the earliest node responsible) , but, the dependency graph, in my understanding, it is actually generated by a LLM , so there is a chance such graph contain incorrect or missing dependencies. -> localisation relies on potentially incomplete set of dependencies

Questions for authors

in terms of novelty, what are the precise algorithmic differences between rectifyFlow's selective rectification and existing partial-replanning or dependency-aware execution methods?

regarding the actual mechanism validation , what is the accuracy of backward deviation localization and downstream impact identification? can the authors evaluate these against workflows with known ground-truth dependency structures?

(important from the practical point of view) how does rectifyFlow compare with cloud-only execution when local GPU computation, hardware amortization, and energy consumption are included in the cost calculation?

3 comments
AuthorsOpenReview ↗

Response to Reviewer hvcd

We thank the reviewer for the constructive and insightful comments. We have carefully addressed the concerns and provide further clarifications and additional experimental results below. We also welcome any further discussion and feedback.

W1 & Q1. Algorithm Design and Differentiation from Existing Methods

(1) Challenges in Jointly Optimizing Task Quality and Cost. Edge–cloud collaboration reduces cloud API costs by offloading routine tool operations to edge devices. However, multi-step tool-use tasks involve frequent observation–execution cycles, where the limited capabilities of small edge models (SMs) can lead to execution deviations. Meanwhile, dependencies among tools may dynamically evolve with runtime outputs and environmental state changes.

Existing Plan-and-Execute methods primarily focus on task planning and execution organization, whereas Dependency-aware methods mainly coordinate task execution through pre-established dependency modeling. Neither sufficiently addresses the interplay between execution deviations and dynamic dependencies: the former may trigger frequent cloud-side corrections due to unreliable edge execution, while the latter may suffer from inaccurate deviation diagnosis and recovery when initial dependency structures fail to capture runtime changes. Therefore, how to leverage runtime evidence to improve execution reliability and dependency modeling while minimizing unnecessary cloud intervention remains a key challenge in jointly optimizing task quality and execution cost.

(2) RectifyFlow's Algorithmic Design. To address these challenges, RectifyFlow establishes an execution-feedback-driven dynamic loop that integrates planning, execution, and rectification. Its dual-view plan connects edge execution with cloud-side correction. The cloud then traces the deviation source through backward deviation localization and identifies affected downstream operations through forward impact analysis, accordingly updating the dependency graph and execution plan to rectify only affected operations while preserving unaffected results. The key is to directly couple runtime feedback with dependency analysis, allowing execution evidence to continuously refine dependency modeling and dependency relations to guide dynamic rectification scope. This mechanism mitigates error propagation and redundant replanning, thereby jointly optimizing task quality and execution cost.

(3) Experimental Validation. On BFCL-V4 and ToolSandbox, RectifyFlow retains 94.6% and 91.8% of Cloud-only performance while reducing cloud API costs by factors of approximately 2.5 and 2.1, respectively. These results demonstrate a favorable trade-off between task quality and cloud API cost.

AuthorsOpenReview ↗

Response to Reviewer hvcd

W2 & Q3. Local Deployment Overhead Analysis

We thank the reviewer for highlighting the importance of local deployment costs. We agree that considering only cloud API expenses does not fully capture the costs associated with edge–cloud collaborative execution. Therefore, we have supplemented our analysis with average reference measurements of GPU energy consumption per task and examined the corresponding electricity costs and hardware requirements.

(1) GPU Electricity Costs. We additionally measured the average GPU energy consumption per task, which was approximately 0.182 Wh/task when using an 8B-parameter edge model. As shown in Table 1, across an electricity price range of $0.05–$0.50/kWh, the combined cloud API and GPU electricity costs of RectifyFlow range from 1.0661 × 10⁻³ to 1.1480 × 10⁻³ per task, representing a 47.17%–50.94% reduction compared with the cloud-only approach. Even at the highest electricity price, a cost margin of approximately 1.025 × 10⁻³ per task remains available to offset hardware depreciation and other local deployment expenses.

(2) Hardware Requirements. Local deployment requires only a small-scale model, such as an 8B-parameter model, which can now be deployed on appropriately configured consumer-grade hardware. Furthermore, our experimental results demonstrate that the 1.7B configuration can also achieve comparable task execution performance on ToolSandbox, further indicating that a lightweight deployment option is feasible for resource-constrained home or office devices.

(3) Overall Cost Implications. These results demonstrate that RectifyFlow maintains a substantial cost advantage even after accounting for local GPU electricity expenses. Depending on hardware prices, utilization rates, and device lifespans, the proposed approach has the potential to further reduce overall deployment costs. We will also clarify the distinction between "cloud API cost savings" and "estimated deployment costs" in the revised manuscript.

Table. 1 API and GPU Electricity Cost Comparison on ToolSandbox

Electricity Price (USD/kWh)Cloud-only API CostRectifyFlow API CostGPU Electricity CostRectifyFlow API + GPU ElectricityReduction vs. Cloud-only
0.052.17301.05700.00911.066150.94%
0.152.17301.05700.02731.084350.10%
0.302.17301.05700.05461.111648.85%
0.502.17301.05700.09101.148047.17%
AuthorsOpenReview ↗

Response to Reviewer hvcd

W3 & Q2. Concerns Regarding the Accurate Identification of Causal Dependencies

We thank the reviewers for raising this important question. We would like to clarify that RectifyFlow does not rely solely on the initially LLM-generated dependency graph. Instead, as described in §4.3, it further refines the DAG based on runtime outputs, state changes, and interruption feedback. When previously unidentified prerequisites are revealed, the corresponding nodes and dependencies are incorporated before downstream impact analysis, allowing the diagnosis to leverage execution evidence in addition to the initial dependency structure.

To further clarify the effectiveness of this mechanism, we conduct additional evaluations on ToolSandbox workflows.

(1) Backward Deviation Localization. We evaluate localization accuracy against ground-truth deviation sources, obtaining the following results:

Table 2. Deviation Source Localization Accuracy

MethodDeviation Source Localization Accuracy
DeepSeek-Flash91.23%
GPT-5.6-Terra90.17%
GPT-6.1-Sol94.43%

These results demonstrate consistently high ground-truth localization accuracy (90.17%–94.43%) across different models.

(2) Downstream Impact Identification. We additionally conduct a cross-model structural audit:

Table. 3 Cross-Model Structural Audit of Deviation Localization and Downstream Impact Analysis

Audit MetricDeepSeek-FlashGPT-5.6-TerraGPT-6.1-Sol
Deviation-to-Interruption Reachability100%100%100%
Downstream Impact Identification Accuracy89.66%94.12%100%

The first metric verifies the existence of a dependency path from the localized deviation source to the interrupted node, while the second measures whether the identified impact set matches the downstream nodes reachable in the DAG. The results demonstrate consistent structural support for localization and high graph-consistent downstream impact identification across models.

Overall, these findings clarify that RectifyFlow combines execution-guided dependency refinement with accurate backward localization and consistent downstream impact analysis, rather than relying exclusively on an initially generated DAG.

Comments on the paper

1 comment
AuthorsOpenReview ↗

General Response by Authors

We sincerely thank reviewers hvcd, kqpr, and 2NSW for their time and effort throughout the review process. Their comments and constructive feedback have helped us further clarify RectifyFlow's technical contributions and strengthen its empirical evidence.

Strengths Acknowledged by the Reviewers. All three reviewers acknowledged the technical contribution of RectifyFlow's dual-view planning design. They also recognized its practical value in balancing task quality and cost, its deployment motivation, and the substantial empirical support provided by extensive baseline comparisons and ablation studies.

The following briefly summarizes our revisions and additional evidence addressing the reviewers' main concerns:

  1. Novelty and Technical Positioning (hvcd, 2NSW). We further clarified the distinctions between RectifyFlow and existing plan-and-execute and dependency-aware methods, and added comparisons and analyses involving LLMCompiler, ATG, SPIN, EdgeWise, and EcoAgent, further highlighting RectifyFlow's novelty and advantages over existing approaches.

  2. Dependency-Aware Plan Rectification (hvcd, 2NSW). To address concerns about potential omissions in the initial dependency graph and the evidence underlying deviation localization, we further clarified how execution feedback and runtime evidence support evidence-constrained deviation localization and impact analysis. Cross-model evaluations demonstrate a deviation source localization accuracy of 90.17%–94.43% and a downstream impact identification accuracy of 89.66%–100%. We also clarified the semantics of state-consistency rectification and explained that pre-execution safeguards against irreversible actions constitute a complementary safety mechanism orthogonal to runtime plan rectification.

  3. Deployment Cost and Multi-Turn Efficiency (hvcd, kqpr). We added a cache-aware cost analysis, showing that RectifyFlow's cost advantage and the paper's main conclusions remain unchanged regardless of whether cache discounts are considered. Under cache-aware pricing, its cloud API cost is 67.84% lower than Cloud-only. We also analyzed local GPU energy consumption, electricity costs, and hardware requirements. Even after accounting for GPU electricity costs, RectifyFlow achieves cost savings of 47.17%–50.94%. In multi-turn interactions, 92.90% of follow-up messages reuse existing plans, avoiding redundant replanning.

  4. Evaluation Robustness and Presentation (2NSW). We cross-checked benchmark results against execution traces and confirmed that the evaluation conclusions remained unchanged. We also provided detailed evaluation results using a second cloud model, GPT-5.6-Terra. We also supplemented the failure-mode analysis to further characterize RectifyFlow's recovery behavior. Furthermore, we separated the local recovery budget analysis from the component ablation experiments into distinct tables for greater clarity.

We sincerely appreciate the reviewers' valuable feedback and welcome further discussion. We hope that the clarifications and additional evidence address the reviewers' concerns. We welcome further discussion and hope the reviewers will reassess the paper in light of these revisions.

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

Related papers

Discussion (0)

Sign in to comment.