acceptodds
Under review as a conference paper at ICLR 2027

SAVE-WAM: Speculative Action Verification with Environment Feedback for Asynchronous World-Action Models

Abstract

Large generative robot policies often adopt asynchronous inference to reduce execution latency, but this introduces generation discrepancy: actions are generated from observations obtained before all previously predicted actions have been executed. Although existing methods attempt to mitigate this discrepancy through calibration during action generation, there lacks feedback from newer observations affected by ongoing execution. As a result, action generation remains open-looped, allowing accumulated prediction errors and eventually causing the trajectory to deviate from the synchronous inference. Therefore, we aim to explicitly model and correct the discrepancy introduced by asynchronous action prediction in a closed-looped manner. Inspired by speculative decoding in language models, we introduce , a training-free post-generation feedback mechanism for asynchronous World-Action Models. SAVE-WAM treats asynchronously generated actions as speculative drafts and verifies them by measuring their deviation from the corresponding synchronous trajectory. Using updated observations during execution, the verifier detects excessively deviated trajectory, and triggers the replanning. As a plug-in mechanism, SAVE-WAM can be integrated with existing asynchronous inference methods to correct generation discrepancies with modest overhead, thereby improving the accuracy-efficiency trade-off. On LingBot-VA with FDM, SAVE-WAM improves success over unverified asynchronous execution from 2% to 42% on and from 82.76% to 92.76% overall, while retaining 73.8% latency overlap. Moreover, verification enables the use of larger action chunks without degrading task success, providing an additional dimension for improving generation efficiency. With a larger chunk size, SAVE-WAM achieves up to 1.97 higher action-generation throughput while maintaining a comparable success rate.

Primary area:
applications to robotics, autonomy, planning
Keywords:
world-action models, robot learning, asynchronous inference, speculative execution, feedback control, real-time robot control

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_v9FAOpenReview ↗
Rating
2
Confidence
3
Informativeness
2
Presentation
2
Soundness
2
Read review
Paper summary

Large robot policies often use asynchronous inference to avoid pauses: the next action chunk is generated while the previous one is still executing. The cost is that new actions are conditioned on stale observations and are executed open-loop, so errors accumulate and the trajectory drifts from what synchronous inference would produce. Inspired by speculative decoding, SAVE-WAM treats asynchronously generated actions as drafts and verifies them with newer observations during execution. Verification uses a single velocity-field evaluation: the draft is noised to flow time τ, and the predicted velocity under the new observation is compared with the velocity implied by the draft. If the score exceeds a threshold, the remaining actions are discarded and the policy replans. Verification is also run one segment ahead so that it overlaps with execution. The method is training-free and plugs into existing asynchronous schemes (FDM, RTC). On RoboTwin 2.0 with LingBot-VA, it raises success from 82.76% (Async-64) to 92.76%, on par with Sync-16, while executing about 1.97× more actions per policy call.

Critical strengths

The method is simple and practical. It needs no training, can be added on top of existing asynchronous schemes, and replaces full re-inference with a single forward call for verification.

The key comparison is convincing. SAVE-WAM and FDM Async-32 have nearly the same average executed chunk size (31.55 vs. 32) and the same inference time (30.99 s), yet SAVE-WAM’s success rate is about 7 points higher (92.76% vs. 85.64%). This shows that the gain comes from verification itself, not just from using shorter chunks.

Critical weaknesses

The efficiency claims are misleading. The “1.97× throughput” refers only to executed chunk size, not actual speed. In wall-clock completion time, SAVE-WAM is slower than the asynchronous baselines it builds on: 91.43 s vs. 76.66 s (Async-64) and 80.31 s (Async-32) for LingBot-VA, and 41.02 s vs. 34.97 s (RTC) for FastWAM, i.e., 14–19% slower. It is only about 7% faster than Sync-16 (97.97 s), and it is also slower than RTC on LIBERO (7.15 vs. 6.50 s). Moreover, SAVE-WAM and Async-32 report identical inference time, yet SAVE-WAM takes 11 s longer per episode, and the paper does not explain where this overhead comes from. Completion time is also averaged only over successful episodes, which differ across methods, so the comparison is biased. In essence, the method trades time for success rate, and presenting it as an efficiency improvement in the abstract and contributions overstates the result. The “73.8% latency overlap” in the abstract is never defined in the main text.

The theorem adds little in practice. The bound depends on the unknown quantities δ_θ, δ_str, and L_x, and requires L_x(1−τ) < 1, so it cannot be checked in practice; δ_str effectively assumes the flow is nearly straight. The real support for the verifier is the empirical correlation in Appendix A.2, not the theorem.

Questions for authors

Since SAVE-WAM and FDM Async-32 have the same inference time but SAVE-WAM takes about 11 s longer per episode, could you break down the end-to-end time into verification, replanning, and waiting? Please also report completion time on the episodes where all compared methods succeed, so that the time comparison is not biased by different success sets.

Several closely related adaptive-execution methods are cited but not compared, especially those that check consistency between imagined and real observations (Wang et al., 2026b; VLA-Corrector; Rethink Before You Execute) and the denoising-variance approach (Feng et al., 2026). How does SAVE-WAM compare with them in success rate and wall-clock time when applied to the same asynchronous backbones?

5 comments
AuthorsOpenReview ↗

Authors' Rebuttal Comments for Reviewer v9FA (Part1/2)

We sincerely thank Reviewer v9FA for the detailed and constructive feedback. Thank to the reviewer for acknowledging our feedback on improving the success rate. We have highlighted the corresponding revisions in blue in the revised manuscript. Our point-by-point responses are provided below.

W1&Q1: The efficiency claims are misleading.

Thanks to reviewers suggestions and we have modified the claims in abstract to the actual speed up in real robot experiment in the revised version Sec.5.3. We would like to clarify that SAVE-WAM targets a different point in the reliability–latency trade-off. Native asynchronous methods such as FDM and RTC are optimized for low latency, but their speculative actions can deviate from the actual execution trajectory without feedback. SAVE-WAM introduces verification and replanning overhead to recover this lost reliability while retaining the benefits of asynchronous execution.

(Q1-1) Why completion time is averaged only over successful episodes?

A: Failed rollouts are excluded because the simulator imposes a maximum action-step limit, causing unsuccessful episodes to terminate at the action cap rather than upon actual task completion. Their recorded durations are therefore censored and cannot provide a meaningful comparison of task completion time. And in our calculation, completion time on the episodes where all compared methods succeed is close to completion time on the episodes where one method succeed:

TaskMethodSuccessful-episode time (s)All-Successful-episode time (s)Error
Hanging Mug (Clean)SAVE-WAM138.995139.1040.109
Hanging Mug (Clean)FDM Async-32128.688128.0370.651

(Q1-2) The paper does not explain where this overhead comes from

A: The additional overhead mainly comes from synchronous replanning triggered by rejected verifications. SAVE-WAM and Async-32 have similar average executed action horizons and thus comparable policy generation costs. However, Async-32 overlaps policy inference with action execution, achieving shorter completion times at the cost of lower success rates. In contrast, SAVE-WAM selectively introduces synchronous replanning when the verifier detects potentially invalid actions. These replanning steps cause additional execution stalls but substantially improve task success rates.

(Q1-3) Define and derive the 73.8% overlap figure

A: Overlap ratio (73.8%) measures the fraction of accumulated policy inference time hidden by asynchronous execution, rather than the proportion of total episode time. For LingBot-VA on RoboTwin-clean, the average accumulated inference time is 30.99 s, while the average blocking time due to rejected verifications and subsequent synchronous replanning is 8.12 s. Therefore, the estimated inference-time overlap ratio is

R&#95;{\mathrm{overlap}}=\frac{T&#95;{\mathrm{infer}}-T&#95;{\mathrm{blocking}}}{T&#95;{\mathrm{infer}}}=\frac{30.99-8.12}{30.99}=0.738.

Breakdown of time

We further provide a breakdown of the timing costs to clarify the source of the additional overhead.

Timing componentAsync-32 (s)Async-64 + SAVE-WAM (s)
Accumulated policy generation time30.98630.993
One-step verification time (Async)02.85
Synchronous replanning / blocking time08.12
End-to-end episode time80.3191.43

The increased end-to-end latency mainly comes from verification-triggered synchronous replanning. Note that the reported end-to-end time also includes action execution in the physics simulator, whose execution overhead contributes to the overall latency. We additionally conduct real-world robot experiments to evaluate the method beyond simulation below to persue visible acceleration.

(Q1-4) Completion time in real-robot tasks

A: In a simulated environment, physical simulators often take a long time. Therefore, in fully asynchronous reasoning, the model inference delay is completely concealed. The total delay, which is the time it takes for the physical simulator to execute all actions, is already the shortest possible time. A larger action horizon does not demonstrate significant performance advantages. We further conducted experiments in real-machine scenarios. By adapting the execution frequency and action horizon, a larger action horizon can improve execution efficiency. It is possible to support a larger action horizon while ensuring task success rate. We also add the results and analysis in Sec.5.3.

TaskCube DisturbanceSync-16 (SR / s)Async-16 (SR / s)Async-32 (SR / s)Async-32 + SAVE-WAM (SR / s)
Cube-to-PlateNo90% / 44.180% / 38.740% / 23.990% / 28.5
Dynamic PickYes70% / 50.630% / 46.210% / 32.870% / 33.4

(please continue to the next part)

AuthorsOpenReview ↗

Authors' Rebuttal Comments for Reviewer v9FA (Part2/2)

(Inherited from the previous part)

W2: The theorem adds little in practice.

We agree that these empirical results provide more direct evidence of the practical effectiveness of the verifier than the theoretical bound alone. Following the reviewer's suggestion, we will move the key empirical validation results into the main paper.

Q2: Several closely related adaptive-execution methods are cited but not compared

A: We appreciate the reviewer for pointing out these closely related works. We have expanded our comparisons to include publicly available implementations of VLA-Corrector[1] and the denoising-variance approach (AutoHorizon[2]) with FastWAM. And unfortunately, due to the lack of open-source code and training datasets for Rethink Before You Execute[3] and FFDC[4], we are unable to condduct experienment on them.

We emphasize that SAVE-WAM differs from these methods in its design objective and integration requirements. Specifically, SAVE-WAM is a training-free, post-generation feedback mechanism supporting asynchronous action execution.

In contrast, VLA-Corrector introduces an additional training-based correction mechanism. The denoising-variance approach estimates uncertainty from the denoising process, but its original implementation does not natively support asynchronous action execution. We have therefore evaluated the available methods under FastWAM and added the corresponding comparisons:

SuiteOurs (SR / Time)AutoHorizon (SR / Time)VLA-Corrector (SR / Time)
LIBERO-1090.00% / 10.44s91.20% / 12.19s88.00% / 18.86s
LIBERO-Goal93.00% / 5.82s94.40% / 5.23s92.00% / 9.51s
LIBERO-Spatial94.60% / 5.96s91.80% / 5.81s93.40% / 9.78s
LIBERO-Object99.00% / 6.38s97.40% / 6.42s95.40% / 11.15s
Overall94.15% / 7.15s93.70% / 7.37s92.20% / 13.06s

Overall, SAVE-WAM achieves the highest average success rate (94.15%) while maintaining the lowest average completion time (7.15 s). These results demonstrate that SAVE-WAM provides a favorable trade-off between task success and execution efficiency, without requiring additional training and while supporting asynchronous action execution.


Reference

[1] Yi Pan, Miao Pan, Qi Lu, Jiaming Huang, Man Zhang, Siteng Huang, Xin Li, Jie Zhang, Yongliang Shen, Xuhong Zhang, et al. VLA-Corrector: Lightweight Detect-and-Correct Inference for Adaptive Action Horizon. arXiv preprint arXiv:2607.01804, 2026b.

[2] Haoxuan Wang, Gengyu Zhang, Yan Yan, Ramana Rao Kompella, and Gaowen Liu. VLA Knows Its Limits: Adaptive Execution Horizons for Robot Policies. arXiv preprint arXiv:2602.21445, 2026a.

[3] Feng Ye, Yiming Zhao, Yong Yu, Hongxu Zhou, Yong Pan, Yuan Xue, Peng Jia, and Chuanmin Jia. Rethink Before You Execute: Adaptive Execution for World Action Models. arXiv preprint arXiv:2608.09492, 2026b.

[4] Rui Wang, Yue Zhang, Jiehong Lin, Kuncheng Luo, Jianan Wang, Zhongrui Wang, and Xiaojuan Qi. When to Trust Imagination: Adaptive Action Execution for World Action Models. arXiv preprint arXiv:2605.06222, 2026b.

AuthorsOpenReview ↗

Kind Reminder from the Authors

Dear Reviewer v9FA,

Thank you again for your valuable comments and feedback. As the reviewer–author discussion period will conclude in less than 24 hours, we would greatly appreciate it if you could let us know whether our responses have adequately addressed your concerns or if there are any remaining questions we could further clarify.

We sincerely appreciate your time and consideration, and look forward to hearing from you.

Best regards,
The Authors

Reviewer_gM8uOpenReview ↗
Rating
3(+1)
Confidence
3
Informativeness
2
Presentation
1
Soundness
2
Read review
Paper summary

This paper proposes a speculative-decoding style method for verifying and refinding draft action chunks in robotic control. The paper frame asynchronous action sequences as speculative drafts, validating them against equivalent synchronous rollout paths. By leveraging real-time sensory feedback throughout execution, this verification mechanism identifies trajectories exhibiting severe drift and prompts policy replanning.

Critical strengths
  1. The proposed method does not require any further fine-tuning or demonstrations. In particular, the model uses a verifier that is the same as the actor model, which makes the proposed method particularly convenient.

  2. The method borrows from speculative decoding - an inference approach used widely for language models, which lends some guarantees for practical usefulness.

  3. The paper tests on some highly appropriate test beds. For example,in the Fig. 4 gripper misalignment, we see that the policy’s own execution drifts from what the stale draft assumed, which is a common failure mode for async execution as discussed in the paper. The paper demonstrates decently strong performance on the tasks and benchmarks that the method has been tested on.

Critical weaknesses
  1. Writing quality is poor: several equations are missing key definitions. What is G\mathcal{G} and what is gg in equation (7)? What is ξ\xi in equation (8) (the definition “coupled flow noise” is certainly insufficient for clarity)? Even in cases where the definitions are provided, the writing is quite terse. For example, this section, which is crucial for understanding the main method, requires a lot of effort from the reader to unpack but the paper goes through it far too rapidly: “This provides a low-cost verification signal without generating a new action trajectory. In practice, we account for heterogeneous action semantics and scales through dimension-wise weighting: discrete gripper open/close commands are treated as hard consistency constraints, while continuous dimensions are normalized by their average magnitudes.”
  2. Theorem 1 seems to crucially rely on the bound δstre\delta_\mathrm{stre}. Why is this a realistic assumption especially when the actor is either in an out-of-distribution state or is operating in a highly stochastic environment? Perhaps more importantly, the bund in equation (11) seems particularly weak – it is linear in the important assumptions you have made (which are ultimately not justified).
  3. Several crucial baselines are not considered in the experiments: EMA [1] and BID [2] for example.
  4. All experiments are done in highly stationary environments which do not truly test the problem of reactivity. The method should be tested on environments with high stochasticity or multi-agent settings for example.
  5. There needs to be more detailed study of how the method really works in practice. One immediate question i have for example is how often rejections happen and whether they tend to happen early in a draft or late.
  6. The paper would benefit from a study of the sensitivity to τ\tau. The threshold sweep (Fig. 3) covers a single task, Hanging Mug, and the paper doesn’t say whether one ϵver\epsilon_\mathrm{ver} is used across all task (or the distribution of values used in these experiments).
Questions for authors

See the discussion on weaknesses.

5 comments
AuthorsOpenReview ↗

Authors' Rebuttal Comments for Reviewer gM8u (Part1/2)

We sincerely thank the reviewer gM8u for the detailed and constructive feedback. Thank you for recognizing the training-free nature and practical convenience of SAVE-WAM, its connection to speculative decoding, and its effectiveness on representative asynchronous-execution failure cases and benchmarks. We apologize that the original manuscript did not sufficiently explain some important implementation details and experimental settings. In response, we have substantially revised the paper, added new baseline and real-robot experiments, and expanded the analysis of the verifier's behavior with blue sentences in PDF. Our point-by-point responses are provided below.

W1: Insufficient clarity of the verifier implementation

A: We apologize for the insufficient explanations in the original manuscript. We have revised the relevant equations and expanded the description of the verification mechanism.

Given a draft action sequence in the backbone's normalized action space, Aˉd\bar{\mathbf A}^{\mathrm d}, we sample Gaussian noise ξ∼N(0,I)\boldsymbol\xi\sim\mathcal N(0,I) with noise level τ\tau and construct a noisy action:

\mathbf Z&#95;{\tau}^{\mathrm d}=(1-\tau)\bar{\mathbf A}^{\mathrm d}+\tau\boldsymbol\xi.

The corresponding target flow velocity is:

\mathbf v&#95;{\mathrm{target}}^{\mathrm d}=\boldsymbol\xi-\bar{\mathbf A}^{\mathrm d}.

Here, coupled flow noise means that the same noise sample ξ\boldsymbol\xi is used to construct both the noisy action and its target velocity. The verifier evaluates the backbone's action vector field once using the updated observation ovo^{\mathrm v}:

\hat{\mathbf v}&#95;{\tau}^{\mathrm d}=v&#95;{\theta}\left(\mathbf Z&#95;{\tau}^{\mathrm d},o^{\mathrm v},\tau\right).

and computes the residual:

\mathbf r&#95;{\tau}=\hat{\mathbf v}&#95;{\tau}^{\mathrm d}-\mathbf v&#95;{\mathrm{target}}^{\mathrm d}.

This provides a low-cost verification signal with only one action-vector-field evaluation, without requiring a full denoising rollout or generating a new action trajectory.

We further clarify how heterogeneous action dimensions are handled. We divide the action dimensions into three groups according to their semantics: position, rotation, and gripper. For each group k∈{p,r,g}k\in\lbrace p,r,g\rbrace, we compute the normalized mean squared one-step velocity residual:

e&#95;{k}=\frac{1}{n&#95;{k}}\lVert\hat{\mathbf v}&#95;{\tau,k}-\mathbf v&#95;{\mathrm{target},k}\rVert&#95;{2}^{2}.

where n&#95;{k} is the number of dimensions in group kk, and the residuals are computed in the backbone's action space. The overall verification score is a weighted combination of these group-wise errors:

S=0.65e&#95;{p}+0.20e&#95;{r}+0.15e&#95;{g}.

A candidate action segment is accepted only if its weighted verification score satisfies S≤λS\leq\lambda, where λ=0.004\lambda=0.004 is the fixed threshold for the corresponding backbone/benchmark configuration.

This design accounts for differences in action semantics while preventing a low overall verification score from masking significant gripper inconsistencies. We have expanded Appendix A.6 to clarify the group definitions, score computation, normalization, and acceptance criteria.

W2: Why is this a realistic assumption especially when the actor is either in an out-of-distribution state or is operating in a highly stochastic environment?

A: We thank the reviewer for raising this important concern. We would like to clarify that SAVE-WAM is designed to address execution-induced discrepancies in asynchronous inference, rather than the fundamental OOD generalization limitations of the underlying policy. Our verifier is tightly coupled with the policy, using the same vector field to assess whether speculative actions remain consistent with updated observations. Therefore, when the underlying policy is capable of handling the current state, our method can detect and correct deviations caused by asynchronous execution. However, if the policy itself fails to interpret an OOD state or produces systematically incorrect predictions, the verifier may inherit these errors and cannot guarantee their correction. We acknowledge that the original bound is a conservative worst-case guarantee based on the triangle inequality.

What is more, we also provide experimental results in Appendix.A.2 to better prove that this approximation can also make a similar decision with the oracle situation.

(please continue to the next part)

AuthorsOpenReview ↗

Authors' Rebuttal Comments for Reviewer gM8u (Part2/2)

(Inherited from the previous part)

W3: Missing comparisons with EMA and BID

A: We appreciate this suggestion. We have added EMA and BID [1] as additional baselines and evaluated them on the full LIBERO benchmark with FastWAM.

The results are summarized below:

EMA (Exponential Moving Average) applies temporal ensembling by exponentially averaging overlapping actions from consecutive predicted chunks. BID (Bidirectional Decoding) samples multiple candidate action chunks and selects the best one based on backward coherence and forward contrast against strong and weak policy predictions, introducing additional sampling and computation. In comparison, SAVE-WAM uses a lightweight one-step flow-based verifier to validate speculative actions, demonstrating a more favorable performance–efficiency trade-off.

MethodLIBERO-10LIBERO-GoalLIBERO-SpatialLIBERO-ObjectOverall
EMA78.00% / 9.7988.40% / 4.8090.00% / 6.0594.00% / 5.4987.60% / 6.34
BID87.20% / 12.1092.60% / 8.6693.80% / 8.7398.00% / 9.4392.90% / 9.48
SAVE-WAM (Ours)90.00% / 10.4493.00% / 5.8294.60% / 5.9699.00% / 6.3894.15% / 7.15

Each entry reports success rate (%) / average successful-episode time (s).

W4: The method should be tested on environments with high stochasticity

A: To address this concern, we have added real-robot experiments, including pick-and-place task and dynamic pick where the cube is moved during execution.

The experiments compare synchronous execution, native asynchronous execution with different draft horizons, and asynchronous execution with SAVE-WAM.

TaskCube DisturbanceSync-16 (SR / s)Async-16 (SR / s)Async-32 (SR / s)Async-32 + SAVE-WAM (SR / s)
Cube-to-PlateNo90% / 44.180% / 38.740% / 23.990% / 28.5
Dynamic PickYes70% / 50.630% / 46.210% / 32.870% / 33.4

These results provide additional evidence that SAVE-WAM can use execution-time feedback to handle unexpected environmental changes on real hardware.

W5: How often rejections happen and whether they tend to happen early in a draft or late.

A: We thank the reviewer for this suggestion. We have extended our analysis of the verifier's behavior using execution logs.

First, the rejection frequency is directly controlled by the verification threshold, providing an additional trade-off between execution efficiency and action reliability. A stricter threshold leads to more frequent rejections and shorter accepted prefixes, whereas a more permissive threshold allows longer action segments to be executed.

Second, our analysis reveals that rejection rates tend to increase toward later positions in a draft. This is consistent with the intuition that prediction discrepancies can accumulate over a longer speculative horizon.

Moreover, rejections are not uniformly distributed across action types. They occur more frequently around critical interaction stages, particularly when approaching an object.

We will include the corresponding rejection statistics in the revised manuscript. The following table illustrates these trends in the task Hanging Mug. And we also expand analysis in Appendix A.8.

ThresholdOverall rejection rate (%)Early (0–25%)Middle (25–75%)Late (75–100%)
0.00440.58.238.576.8
0.00634.987.734.263.8
0.00823.035.222.741.5
0.0115.952.915.829.3

W6: Sensitivity to the verification threshold and task-specific settings

A: We appreciate this question and would like to clarify that we use a single fixed threshold across all tasks.

The threshold determines the acceptance criterion, while the accepted action horizon adapts automatically according to the task and current execution state. Consequently, different tasks can produce different effective chunk sizes even under the same threshold.

For example, in relatively simple and predictable tasks, such as Open Laptop, the verifier is expected to accept longer action prefixes. In more challenging tasks, such as Hanging Mug, deviations are more likely to be detected, resulting in earlier rejection and shorter accepted prefixes.

Figure 3 illustrates the operating frontier obtained by sweeping the threshold on Hanging Mug. Its purpose is to demonstrate the trade-off between success rate and effective action chunk size, rather than to suggest that different thresholds are selected for different tasks.

And for noise level τ\tau, we follow the experiments in Appendix A.2, and find τ=0.3\tau=0.3 is appropriate:

Noise Level (τ\tau)AUROC
0.10.647
0.20.840
0.30.900
0.40.868
0.50.845
AuthorsOpenReview ↗

Kind Reminder from the Authors

Dear Reviewer gM8u,

Thank you again for your valuable comments and feedback. As the reviewer–author discussion period will conclude in less than 24 hours, we would greatly appreciate it if you could let us know whether our responses have adequately addressed your concerns or if there are any remaining questions we could further clarify.

We sincerely appreciate your time and consideration, and look forward to hearing from you.

Best regards,
The Authors

Reviewer_uVFEOpenReview ↗
Rating
3(+1)
Confidence
2
Informativeness
2
Presentation
2
Soundness
3
Read review
Paper summary

SAVE-WAM proposes a training-free verification mechanism for asynchronously executed World-Action Models. It treats generated action chunks as drafts and uses newer observations to decide whether upcoming segments should be executed or discarded. The verifier noises a draft segment, evaluates the policy's vector field once under the updated observation, and measures the discrepancy from the velocity associated with the draft. Rejection triggers replanning. Verification is scheduled during execution of the preceding segment to reduce exposed latency.

The paper provides a conditional bound relating the one-step residual to disagreement with a freshly generated reference action segment. Experiments combine SAVE-WAM with LingBot-VA/FDM and FastWAM/RTC on RoboTwin 2.0 and LIBERO. The results show substantial recovery of success relative to unverified asynchronous execution, with additional runtime cost, and lower successful-episode completion times than the selected synchronous baselines.

Critical strengths
  1. Tables 1–2 evaluate two backbones, two asynchronous mechanisms, and multiple benchmark settings. For LingBot-VA, SAVE-WAM improves RoboTwin-clean success from 82.76% to 92.76% and LIBERO-10 success from 69.40% to 95.80%. The latter is close to the synchronous baseline's 96.00%, with a lower reported successful-episode completion time. These results provide meaningful evidence that checking drafts against newer observations can address failures of asynchronous execution.

  2. Appendix A.2 reports Spearman correlations of 0.719 and 0.779 between the one-step score and oracle action discrepancy, with episode-bootstrap confidence intervals, and AUROC values of 0.896 and 0.900 for oracle rejection. Table 3 also compares oracle, one-step, and ahead verification. Although limited to a few tasks, these analyses support the proposed approximation and help explain the practical mechanism.

Critical weaknesses
  1. The central verifier is not specified sufficiently to reproduce its decisions or establish how the theoretical result applies to the implementation.

Section 4.2 defines an unweighted squared residual, while the implementation additionally normalizes continuous action dimensions and imposes hard gripper-consistency constraints. The PDF does not specify the actual verification noise level, the complete weighted decision rule, how gripper consistency is determined, or how thresholds are selected across tasks and backbones. Figure 3 presents several threshold values for a single task but does not specify the configuration or selection protocol used for the main results. These choices directly determine acceptance frequency, success, and computational cost.

Theorem 1 provides the conditional bound.

doracle≤sτ(Ad,ov)+δθ+δstr1−Lx(1−τ).d_{\mathrm{oracle}} \leq \frac{\sqrt{s_\tau(A^d,o^v)}+\delta_\theta+\delta_{\mathrm{str}}}{1-L_x(1-\tau)}.

The derivation in Appendix A.1 appears valid under the stated assumptions. However, the paper does not establish that Lx(1−τ)<1L_x(1-\tau)<1 holds at the deployed noise level or that the approximation and straightness errors are small enough to make the bound informative. The straightness assumption is substantive: using linear interpolation in flow-matching training does not, by itself, establish that the learned sampling trajectory follows the straight line between a particular noise sample and its generated endpoint.

There is also an unresolved temporal-alignment detail. Ahead verification scores the next segment using an observation obtained while the current segment is still executing. The paper should specify which future block of the oracle output is compared, how intervening committed actions are represented, and how the shorter verification segment is embedded into each backbone's policy input. The existing correlation results are encouraging, but do not resolve these implementation questions.

  1. The evaluation does not yet fully substantiate the headline efficiency claim or isolate the benefit of the verification rule from the replanning schedule.

The reported 1.97×1.97\times improvement is the ratio of average executed actions per full policy inference:

31.5516≈1.97.\frac{31.55}{16}\approx 1.97.

This measures action reuse per full generation call. It does not include the cost of verification calls and is not a measured wall-clock throughput ratio. For the corresponding LingBot-VA RoboTwin comparison, Table 1 reports successful-episode completion times of 97.97 s and 91.43 s:

97.9791.43≈1.07.\frac{97.97}{91.43}\approx 1.07.

The wall-clock improvement is useful, but substantially smaller than the headline number. A clear definition or derivation in the supplied PDF does not accompany the abstract's separate claim of 73.8% latency overlap. Appendix A.5 reports exposed boundary waiting and explicitly notes that its final percentage is not a compute-overlap ratio.

Moreover, completion times are averaged over successful episodes, whose composition changes substantially between methods. This makes the timing comparisons descriptive rather than matched estimates of execution speed. Hardware, controller timing, verification cost, and the inclusion of observation processing and rejected computation also need clearer reporting.

Finally, Table 3 changes both feedback and replanning behavior relative to the fixed Async-64 baseline. Async-32 provides a useful partial control but also changes the proposal horizon. A control that retains the same proposal horizon and matches the replanning budget would more directly establish the benefit of the verification decisions. This is a suggested improvement to the evaluation, rather than a request for a new experimental campaign during rebuttal.

Questions for authors
  1. What noise level, noise-coupling procedure, dimension weights, gripper rule, and verification thresholds produced Tables 1–2? Were thresholds shared across tasks, and what data were used to select them?

  2. When verifying the next segment during execution of the current segment, which block of the oracle output is the reference? How are intervening committed actions and the backbone's full input horizon handled?

  3. Is Theorem 1 intended as a qualitative justification or as a quantitative guarantee for the implemented gate? What existing evidence supports its assumptions at the chosen noise level, and how does the bound relate to the weighted score and hard gripper constraints?

  4. Please define and derive the 73.8% overlap figure, clarify whether 1.97× denotes actions per full generation call, and specify which costs enter the timing measurements. Can the existing logs clarify the effect of conditioning completion-time statistics on success?

3 comments
AuthorsOpenReview ↗

Authors' Rebuttal Comments for Reviewer uVFE (Part1/2)

We thank reviewer uVFE for the insightful comments. Thank to the reviewer for acknowledging our feedback on improving the success rate. We have highlighted the corresponding revisions in blue in the revised manuscript. Our point-by-point responses are provided below.

W1: The PDF does not specify the complete weighted decision rule (Add to Sec.4 and Appendix A.6)

(Q1) What noise level, noise-coupling procedure, dimension weights, gripper rule, and verification thresholds produced Tables 1–2?

A:

Noise level and coupling. We use a fixed noise level of τ=0.3\tau=0.3 for verification. Specifically, we use the same Gaussian noise sample ξ\xi to construct both the noisy draft action and its target flow velocity:

\qquad v_{\mathrm{target}}^d=\xi-\bar A^d.$$ This coupled noise construction ensures consistency between the noisy input and the corresponding target velocity. **Dimension weights and gripper rule.** The numerical values of different action dimensions of the robotic arm vary. These dimensions are grouped by position, rotation, and gripper semantics. When calculating the differences in actions, we apply weights to the dimensions of position and angle, ensuring that their mean values are normalized to the same level. $$S=0.65e_p+0.20e_r+0.15e_g.$$ Where $e_p,e_r,e_g$ denote the corresponding action-group errors and the draft actions are accepted when $S<\text{thredhold}$. This design enhances the average action horizon. **Threshold selection and sharing.** We use a fixed verification threshold for all tasks within each backbone/benchmark configuration, rather than tuning thresholds individually for each task. The thresholds used in Tables 1–2 are 0.004. The selection of threshold provides a dimension for adjusting the trade-off between model efficiency and success rate. In our experiment, we chose a threshold of 0.004 to achieve a success rate similar to the synchronous baseline while improving efficiency. > **(Q2) When verifying the next segment during execution of the current segment, which block of the oracle output is the reference? How are intervening committed actions and the backbone's full input horizon handled?** **A:** To clarify the temporal alignment, consider a concrete example where each inference generates 64 actions, divided into segments of 8 actions. At execution step 16, the current segment (actions 16–23) is being executed, while the next segment (actions 24–31) is subject to ahead verification. **Oracle reference.** The oracle is obtained by regenerating the action sequence using the updated observation $o_{16}$. Since the regenerated sequence is indexed relative to the new observation, its first 8 actions correspond to the currently executing interval (16–23). Therefore, the correct oracle reference for the draft segment (24–31) is the **8th–15th actions (indices 8–15) of the regenerated sequence**. **One-step verification and input horizon.** The committed actions (16–23) are retained in the input to maintain temporal alignment, but are not included in the verification score or reconsidered for execution. We compute the verification residual only over the target segment corresponding to the original draft actions 24–31. Thus, ahead verification uses the updated observation to assess the validity of the next unexecuted segment, while preserving the original temporal correspondence between the draft and its regenerated reference. > **(Q3) Is Theorem 1 intended as a qualitative justification or as a quantitative guarantee for the implemented gate? What existing evidence supports its assumptions at the chosen noise level, and how does the bound relate to the weighted score and hard gripper constraints?** **A:** **Empirical evidence.** Appendix A.2 provides practical evidence by comparing the one-step verification proxy against a fully denoised shadow oracle under the same observation. The results demonstrate strong agreement between proxy and oracle decisions: | Task | Paired Decisions | Spearman Correlation | AUROC | |---|---:|---:|---:| | Move Stapler Pad | 76 | 0.719 | 0.896 | | Put Bottles Dustbin | 100 | 0.779 | 0.900 | **Weighted score and gripper constraint.** The bound can also be extended to our implemented weighted score $$S_\tau=0.65e_p+0.20e_r+0.15e_g.$$ Since all weights are positive and the action dimensions are partitioned into normalized groups, the unweighted residual satisfies $$\sqrt{s_\tau}\leq C_w\sqrt{S_\tau},$$ where $C_w$ is a fixed constant determined by the group dimensions, normalization scales, and weights. Substituting this into Theorem 1 gives: $$\operatorname{RMSE}(\hat A,A^\star) \leq \frac{C_w\sqrt{S_\tau}+\delta_\theta+\delta_{\mathrm{str}}} {1-L_x(1-\tau)}.$$ We include this extension in appendix A.6 and we kindly refer the reviewer to this section for further details. > (please continue to the next part)
AuthorsOpenReview ↗

Authors' Rebuttal Comments for Reviewer uVFE (Part2/2)

(Inherited from the previous part)

W2: The evaluation does not yet fully substantiate the headline efficiency claim or isolate the benefit of the verification rule from the replanning schedule.

(Q4-1) Please define and derive the 73.8% overlap figure, clarify whether 1.97× denotes actions per full generation call, and specify which costs enter the timing measurements. Can the existing logs clarify the effect of conditioning completion-time statistics on success?

A: Overlap ratio (73.8%). This measures the fraction of accumulated policy inference time hidden by asynchronous execution. For LingBot-VA on RoboTwin-clean, the average accumulated inference time is 30.99 s, while the average blocking time due to rejected verifications and subsequent synchronous replanning is 8.12 s. Therefore, the estimated inference-time overlap ratio is

Roverlap=Tinfer−TblockingTinfer=30.99−8.1230.99=0.738.R_{\mathrm{overlap}}=\frac{T_{\mathrm{infer}}-T_{\mathrm{blocking}}}{T_{\mathrm{infer}}}=\frac{30.99-8.12}{30.99}=0.738.

Action throughput (1.97×). This denotes the average number of executed actions per full policy generation call. SAVE-WAM achieves an average executed chunk size of 31.55, compared with 16 for the synchronous baseline with comparable success rates, giving 31.55/16=1.97×31.55/16=1.97\times. This indicates fewer full policy generation calls for a comparable amount of action execution.

(Q4-2) Can the existing logs clarify the effect of conditioning completion-time statistics on success?

A: We compute average task completion time over successful rollouts only, and report success rate separately. Failed rollouts are excluded because the simulator imposes a maximum action-step limit, causing unsuccessful episodes to terminate at the action cap rather than upon actual task completion. Their recorded durations are therefore censored and cannot provide a meaningful comparison of task completion time. To better illustrate that the calculation in the paper is valid, we also calculate completion time on the episodes where all compared methods succeed and find it is close to completion time on the episodes where one method succeed (current numbers in paper), for example:

TaskMethodSuccessful-episode time (s)All-Successful-episode time (s)Error
Hanging Mug (Clean)SAVE-WAM138.995139.1040.109
Hanging Mug (Clean)FDM Async-32128.688128.0370.651

(Q4-3) Why is acceleration not significant in the simulated environment?

A: In a simulated environment, physical simulators often take a long time. Therefore, in fully asynchronous reasoning, the model inference delay is completely concealed. The total delay, which is the time it takes for the physical simulator to execute all actions, is already the shortest possible time. A larger action horizon does not demonstrate significant performance advantages. To address this concern, we have added real-robot experiments, including pick-and-place task and dynamic pick where the cube is moved during execution. By adapting the execution frequency and action horizon, a larger action horizon can improve execution efficiency. It is possible to support a larger action horizon while ensuring task success rate. As shown in tables below, SAVE-WAM matches Sync-16 success while reducing completion time from 44.144.1 to 28.528.5,s and from 50.650.6 to 33.433.4,s, corresponding to 1.55×1.55\times and 1.51×1.51\times speedups. We have added these results into revised version in Sec.5.3.

TaskCube DisturbanceSync-16 (SR / s)Async-16 (SR / s)Async-32 (SR / s)Async-32 + SAVE-WAM (SR / s)
Cube-to-PlateNo90% / 44.180% / 38.740% / 23.990% / 28.5
Dynamic PickYes70% / 50.630% / 46.210% / 32.870% / 33.4
AuthorsOpenReview ↗

Kind Reminder from the Authors

Dear Reviewer uVFE,

Thank you again for your valuable comments and feedback. As the reviewer–author discussion period will conclude in less than 24 hours, we would greatly appreciate it if you could let us know whether our responses have adequately addressed your concerns or if there are any remaining questions we could further clarify.

We sincerely appreciate your time and consideration, and look forward to hearing from you.

Best regards,
The Authors

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

Related papers

Loading the map…

Discussion (0)

Sign in to comment.