acceptodds
Under review as a conference paper at ICLR 2027

Noise-Space Safety Corrector for Vision-Language-Action Models

Abstract

Vision-Language-Action (VLA) models have demonstrated strong generalization capabilities across diverse robotic manipulation tasks. However, physical deployment of these models requires satisfying safety constraints while retaining task performance. Existing approaches enforce safety by correcting actions during sampling or projecting them after generation. Although these approaches produce safe actions, they either ignore chunk level dependencies within action sequences or push actions away from the learned behavior of the pretrained policy, thereby degrading task performance. To address these limitations, we propose Noise Safe Corrector (NSC), a test-time safety filter that corrects the noise of a pretrained VLA policy. As the transformation from the noise to the action chunk is deterministic, we can optimize the noise to enforce safety constraints while taking chunk level dependencies into account and preserving pretrained knowledge encoded in the policy. To enforce safety constraints, we use a control barrier function (CBF) formulated in noise space and iteratively solve a quadratic program (QP), which has a closed-form solution. We further prove that NSC obtains a safe action chunk within a finite number of iterations under mild assumptions. Experiments across three simulation environments and real-world robotic tasks show that NSC outperforms baselines in terms of task success rate while satisfying safety constraints.

Primary area:
applications to robotics, autonomy, planning
Keywords:
Vision Language Action Model, Safety

Reviews

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

The paper proposes Noise Safe Corrector (NSC), a training-free safety filter for frozen flow-matching vision-language-action policies. Rather than changing the predicted actions directly, NSC differentiates a chunk-level geometric safety score through the deterministic policy sampler and adjusts its initial noise. Each update solves a single-constraint quadratic program in closed form, combining a direction that improves the linearized safety score with a pull toward the original noise. The full action chunk is then regenerated and checked. The paper proves finite-time recovery for a continuous correction process and finite-step recovery under explicit smoothness, nonzero-gradient, step-size, and update-budget conditions. The evaluation covers a toy navigation problem, SafeLIBERO with two backbones, VLA-Arena, three newly constructed SafeDetour tasks with a third backbone, and a physical pick-and-place demonstration. The real-robot comparison reports 10/10 safe successes for NSC, versus 0/10 for each comparator, under a protocol restricted to initially unsafe upper-route proposals.

Critical strengths

A coherent mechanism for changing an entire proposed behavior while retaining a frozen policy. Equations (8)-(10) make it possible to use the policy Jacobian to coordinate changes across an action chunk, while avoiding retraining a large VLA. The conditional recovery results in Proposition 4.1 and Appendix A.2 give a precise account of when the optimization can find a chunk satisfying its supplied safety score. This is a useful technical contribution beyond an unconstrained heuristic perturbation.

Substantial evidence for improved safe completion across several settings and backbones. Tables 1-3 consistently favor NSC in average safe success, and the 26 percentage point improvement over the strongest filter baseline on SafeDetour is especially meaningful for the stated deadlock/detour motivation. Reporting TSR, CAR, and their joint event SS helps distinguish completing a task from merely stopping safely. The safety-margin sweep in Appendix E also makes a relevant success-versus-clearance tradeoff explicit. These results support the usefulness of the overall method under the tested geometric assumptions.

Critical weaknesses

The comparison does not isolate the noise-space parameterization under matched computation. NSC can regenerate and differentiate through the complete policy repeatedly, with a budget of ten correction updates and additional Armijo evaluations (Appendix B.6). SFM's prediction and correction steps instead share the base policy's fixed flow-evaluation budget. No latency, distribution of actual correction counts, or comparison at matched forward/backward computation is reported. The methods share the geometric barrier according to Section 5.1, and the base/VLSA/NSC action and execution horizons are explicitly matched in Appendix B.3. However, the manuscript attributes baseline failures to independent per-action corrections (Section 5.2), and does not include a full-chunk action-space optimization control or repeated noise sampling/selection under the same safety score and comparable budget. Consequently, the reported gains establish the value of the complete NSC system, but do not establish whether its noise-space parameterization is the decisive improvement. This limits the support for the central mechanism claim and assessment of the practical inference-time tradeoff.

The connection between the conditional optimization guarantee and the executed safety filter is underspecified. Proposition A.1 requires a gradient lower bound, a gradient Lipschitz bound, and a sufficiently small fixed step size and large budget. Experiments instead use adaptive Armijo steps and a fixed budget of ten, without reporting how often correction fails or what the robot executes in that event. Appendix C.1 explicitly says that an unsafe zero-gradient candidate causes the algorithm to report failure, but does not specify the subsequent robot behavior. Appendix B.1 predicts link/gripper clearance from accumulated end-effector translations and holds obstacle geometry fixed over the chunk; thus a certified predicted chunk need not certify the actual motion, especially in the DynamicObstacles evaluation. The manuscript acknowledges known geometry as a limitation, which is appropriate, but does not quantify this prediction/execution gap or connect observed collisions to infeasibility, budget exhaustion, or model mismatch. For a method presented as a safety filter, this missing operational contract materially limits the interpretation of its guarantees. It does not, by itself, invalidate the conditional mathematical results.

Questions for authors

What are median and tail query latencies, numbers of policy forward/backward passes, Armijo evaluations, and correction iterations for NSC and the baselines on the same hardware? At a comparable computational budget, how much of the safe-success gain remains relative to full-chunk action-space correction or sampling several noise candidates and selecting a safe one? Please clarify exactly how the shared chunk safety function is instantiated for SFM, which the manuscript describes as correcting actions independently.

Which differentiable safety function is actually optimized, with what softmin temperature, delta, and Armijo rule? What fractions of queries encounter a near-zero gradient or exhaust the ten-update budget, and what action or stop behavior follows? How are arm-link motion and moving obstacles handled between policy queries, and how often does predicted safety disagree with executed safety? These details determine whether the implementation supports the intended safety interpretation.

Please reconcile the VLA-Arena TBD episode count and L1/L2 evaluation in B.3.2 with the ten episodes and L0-L2 description in Section 5.3, and the two conventions for including epsilon in the safety function. For the physical experiment, were the same ten initial states and initially unsafe proposals paired across methods, and how often does the unfiltered policy initially choose the excluded safe route? This would distinguish conditional correction performance from unconditional deployment performance.

9 comments

We thank the reviewer for their careful reading of our paper and their insightful feedback. We would like to address the reviewer's concerns and questions below.

(W1 & Q1) Isolation of the noise-space parameterization under matched computation

Computational cost

The comparison does not isolate the noise-space parameterization under matched computation. NSC can regenerate and differentiate through the complete policy repeatedly, with a budget of ten correction updates and additional Armijo evaluations (Appendix B.6). SFM's prediction and correction steps instead share the base policy's fixed flow-evaluation budget. No latency, distribution of actual correction counts, or comparison at matched forward/backward computation is reported.

What are median and tail query latencies, numbers of policy forward/backward passes, Armijo evaluations, and correction iterations for NSC and the baselines on the same hardware?

We agree that the comparison should report the computational cost of each method. NSC requires additional computation only when the proposed chunk is unsafe, so we report it both over all queries and over the corrected queries. All methods are measured on the same hardware. The cost is measured on SafeLIBERO Object for π0.5 and GR00T N1.7 and on SafeDetour Toaster for Xiaomi-Robotics-1.

Cost per Query.

BackboneMethodLatency, median (ms)Latency, 99th percentile (ms)Forward passesBackward passesArmijo evaluationsCorrection updates
π0.5Base134.52081000
VLSA141.82151000
SFM168.22121000
NSC, all queries138.65815.80.34.80.3
NSC, corrected queries336.469419.01.418.01.4
GR00T N1.7Base89.5931000
VLSA96.81001000
SFM122.81271000
NSC, all queries108.65894.70.33.70.3
NSC, corrected queries306.359417.01.316.01.3
Xiaomi-Robotics-1Base173.61791000
VLSA219.82371000
SFM302.03331000
NSC, all queries194.19927.50.36.50.3
NSC, corrected queries485.8109925.81.324.81.3

Over all queries, the median latency of NSC is lower than that of SFM for every backbone, because most queries need no correction. The additional cost of NSC appears in the corrected queries and in the tail. VLSA and SFM use only the forward pass of the base policy, without any backward pass, Armijo evaluation, or correction update. For NSC, each correction update uses one backward pass. The candidate steps of the line search are evaluated in parallel, and each of them is one Armijo evaluation with one forward pass. The distribution of the correction updates is reported below.

Distribution of the Correction Updates (% of corrected queries).

Backbone1 update2 updates3 or more updatesBudget exhausted
π0.567.730.12.20.0
GR00T N1.782.013.44.60.0
Xiaomi-Robotics-182.613.44.00.0

More than 95% of the corrections end within two updates for every backbone, and none of them exhausts the budget of ten updates. The comparison under matched computation is reported in the next part.

Controls under a comparable budget

However, the manuscript attributes baseline failures to independent per-action corrections (Section 5.2), and does not include a full-chunk action-space optimization control or repeated noise sampling/selection under the same safety score and comparable budget. Consequently, the reported gains establish the value of the complete NSC system, but do not establish whether its noise-space parameterization is the decisive improvement. This limits the support for the central mechanism claim and assessment of the practical inference-time tradeoff.

At a comparable computational budget, how much of the safe-success gain remains relative to full-chunk action-space correction or sampling several noise candidates and selecting a safe one?

We agree that the original evidence supported only the complete system. As the reviewer suggested, we added the two controls, which are full-chunk action-space optimization (direct full-chunk optimization) and noise sampling and selection (noise resampling). Both use the same safety score and the same budget as NSC. We also compared NSC with SFM under matched latency, where SFM is given the worst-case latency of a corrected query of NSC. VLSA is not included in the matched comparison, because it has no iterative component that can use additional computation. The detailed setup will be added to Appendix G.1 and G.3 of the revised manuscript.

Matched Comparison (TSR / CAR / SS).

MethodSafeLIBERO ObjectVLA-Arena StaticObstaclesSafeDetour Toaster
Direct full-chunk optimization82 / 78 / 7049 / 62 / 3885 / 78 / 70
Noise resampling (same budget)78 / 33 / 3052 / 72 / 4488 / 41 / 38
SFM (matched to the worst-case latency of NSC)78 / 85 / 6948 / 81 / 4472 / 99 / 72
NSC86 / 88 / 7757 / 83 / 5691 / 99 / 91

NSC keeps a gain of 15.3 points of SS on average over full-chunk action-space optimization, 37.3 points over noise sampling and selection under the same budget, and 13.0 points over SFM under matched latency. Thus the gains do not come from the additional computation.

Regarding Section 5.2, direct full-chunk optimization improves the SS over VLSA in Tables 1 to 3 of the manuscript by 11.3 points, so correcting the whole chunk instead of each action explains a part of the baseline failures. The noise-space parameterization adds 15.3 points. We will revise Section 5.2 and the mechanism claim accordingly.

Instantiation of the safety function for SFM

The methods share the geometric barrier according to Section 5.1, and the base/VLSA/NSC action and execution horizons are explicitly matched in Appendix B.3.

Please clarify exactly how the shared chunk safety function is instantiated for SFM, which the manuscript describes as correcting actions independently.

The reviewer's understanding is correct. All methods use the same clearance dk(A)d_k(A), obstacle geometry, and margin ε, so they share the same safe set, in which dk(A)−ϵ≥0d_k(A) - \epsilon \ge 0 holds at every step kk of the chunk.

SFM follows its original formulation [1], in which the CBF condition is enforced independently for each waypoint. With the barrier of waypoint kk, bk=dk(A)−ϵb_k = d_k(A) - \epsilon, it solves one QP per waypoint at every correction step tt,

utk⋆=arg⁡min⁡u ∥u−v~tk∥22s.t.∇bk⊤u+γ(bk)≥0,u_t^{k\star} = \arg\min_{u}\ \lVert u - \tilde{v}_t^{k} \rVert_2^2 \quad \text{s.t.} \quad \nabla b_k^\top u + \gamma(b_k) \ge 0,

where v~tk\tilde{v}_t^{k} is the time-scaled velocity of the flow at waypoint kk and γ\gamma is the finite-time barrier term of SFM, and the slack variable is omitted for brevity. Each waypoint is therefore certified by its own QP, but the corrections are not coordinated across the chunk. Neighboring waypoints can be moved in different directions, so the path can change abruptly within the chunk, and the motion between two certified waypoints is not certified. This is what we meant by correcting actions independently, and it is how SFM collides in Section 5.2. In contrast, NSC uses one function of the whole chunk and one QP in the noise space (Section 4), so all actions change together through the policy.

References

[1] Yang, J., Jang, S., and Han, S. SafeFlowMatcher: Safe and Fast Planning using Flow Matching with Control Barrier Functions. In International Conference on Learning Representations, 2026.

(W2 & Q2) Connection between the guarantee and the executed filter

Specification of the executed filter

The connection between the conditional optimization guarantee and the executed safety filter is underspecified.

Which differentiable safety function is actually optimized, with what softmin temperature, delta, and Armijo rule?

We apologize that these details were missing. The safety function checks the gripper and the wrist link (link 7), each enclosed by an ellipsoid, and it is h(A)=min⁡kdk(A)−ϵh(A) = \min_{k} d_k(A) - \epsilon, where dk(A)d_k(A) is the smallest signed distance between these ellipsoids and the obstacle ellipsoids at step kk. The gradient is computed with the smooth lower bound of this function, in which each minimum is replaced with a softmin (Appendix B.1), while the acceptance test uses the function itself with the hard minimum. The parameters are listed below, and the detailed definitions will be added to Appendix B.1 and B.6 of the revised manuscript.

Parameters of the Executed Filter.

ItemValue
Softmin sharpness (inverse temperature)200 for π0.5 and Xiaomi-Robotics-1, 240 for GR00T N1.7
CBF margin δ0.01
Armijo ruleH(z+ηu)−H(z)≥σ η g(z)⊤uH(z + \eta u) - H(z) \ge \sigma\,\eta\, g(z)^\top u with σ = 0.5. The candidate steps start from 1 (median) and decrease by a factor of 1/2. They are evaluated in parallel, and the largest one that satisfies the rule is accepted
Acceptance testh(A)≥0h(A) \ge 0, evaluated with the hard minimum

Theoretical conditions and failure

Proposition A.1 requires a gradient lower bound, a gradient Lipschitz bound, and a sufficiently small fixed step size and large budget. Experiments instead use adaptive Armijo steps and a fixed budget of ten, without reporting how often correction fails or what the robot executes in that event. Appendix C.1 explicitly says that an unsafe zero-gradient candidate causes the algorithm to report failure, but does not specify the subsequent robot behavior.

What fractions of queries encounter a near-zero gradient or exhaust the ten-update budget, and what action or stop behavior follows?

These conditions (Eq. 16 of Prop. A.1) decide whether a safe chunk is found within K updates, not whether an executed chunk is safe, which follows from the acceptance test h(A) ≥ 0 in Algorithm 1 alone. Regarding the adaptive Armijo steps, the fixed step size of Prop. A.1 is needed only to guarantee the progress inequality in Eq. (20), H(zk+1)−H(zk)≥σ ηk (δ−H(zk))H(z_{k+1}) - H(z_k) \ge \sigma\,\eta_k\,\bigl(\delta - H(z_k)\bigr), and the Armijo line search (Appendix B.6) checks this inequality at every update. Any step that satisfies the fixed-step condition passes this test, so Prop. A.1 holds with the smallest accepted step in place of η. We will add this result as Prop. A.2 (Appendix A.3). Regarding the fixed budget of ten, we chose K = 10 from the bound of Prop. A.1. With η = 0.5 and δ = 0.01, this bound is 10 updates for an initial violation of 15 cm, which is the average width of the obstacles in our experiments. The table below reports how often correction fails and why.

Outcome of the Corrections (K = 10, % of corrected queries).

SettingCertifiedNear-zero gradientBudget exhaustedLine-search failure
SafeLIBERO Object99.75000.25
VLA-Arena StaticObstacles97.950.1601.89
SafeDetour Toaster100000

A near-zero gradient occurs in 0%, 0.16%, and 0% of the corrected queries, and the budget of ten is never exhausted. The line search fails in 0.25%, 1.89%, and 0%. When correction fails, NSC does not execute the chunk and outputs the stop action for that chunk. Appendix C.1 did not specify this behavior, and we will state it there and in Algorithm 1. The details will be added to Appendix B.8 of the revised manuscript.

Reviewer_TpB5OpenReview ↗
Rating
2
Confidence
2
Informativeness
2
Presentation
2
Soundness
2
Read review
Paper summary

This paper introduces the Noise Safe Corrector (NSC), a safety-filtering method for Vision-Language-Action (VLA) models that enables safe intervention by adjusting initial noise, without requiring model retraining. Unlike approaches that directly modify actions or the velocity field during generation, NSC leverages the deterministic mapping from noise to action chunks—inherent to frozen flow-matching strategies—to project safety constraints from the action space into the noise space, where safety gradients are computed via backpropagation. The method then iteratively solves a quadratic program (QP) involving Control Barrier Functions (CBFs)—which admits a closed-form solution—to update the noise and regenerate the action chunks until safety conditions are met or the iteration budget is exhausted. Under assumptions regarding smoothness, non-degeneracy of gradients, and step size, the authors provide an analysis of finite-step safety recovery in both continuous-time optimization and discrete-time iterations. Experiments cover 2D navigation, SafeLIBERO, VLA-Arena, a newly constructed benchmark called SafeDetour, and real-world robotic manipulation using the SO101 platform. The results demonstrate that NSC generally improves the success rate of safety-critical tasks, performing particularly well in scenarios that require proactive detouring to avoid the stagnation often encountered with localized safety-filtering mechanisms.

Critical strengths

Applying safety corrections to the initial noise—followed by the regeneration of the complete action sequence via a frozen policy—provides a direct mechanism for coordinating multiple future actions, while circumventing the need for additional policy training.

The paper addresses not only immediate collisions but also potential hazards in the subsequent stages of an action sequence. Experiments in 2D environments, along with the "SafeDetour" scenario, illustrate that single-step filtering can lead to stagnation, whereas holistic correction enables the selection of an alternative, safe trajectory.

Each correction requires only the gradient of the safety function with respect to the noise, followed by an update using a closed-form quadratic programming (QP) solution—eliminating the need for a general-purpose QP solver. The appendix further distinguishes between continuous-time and discrete-step settings, providing a more rigorous foundation for the safety recovery argument.

The authors validated their method across the π0.5, GR00T N1.7, and Xiaomi-Robotics-1 benchmarks, reporting metrics for task success, collision avoidance, and "safety success." For instance, on the SafeLIBERO benchmark, the average safety success rate for π0.5 improved from 20% (with the baseline policy) to 66%—outperforming two other safety-filtering baselines.

In cases where the underlying policy has already learned multiple potential routes, the proposed method (NSC) can adjust an action sequence—originally destined for a hazardous path—toward a safe one. This serves as a practical demonstration of how a policy’s existing alternative behaviors can be leveraged to achieve obstacle avoidance.

Critical weaknesses

The optimized noise may deviate from the high-probability regions encountered during training or standard sampling; thus, actions generated via the original policy are not guaranteed to remain within the realm of familiar or high-quality behaviors. The current lack of analysis regarding noise drift, noise probability, and performance in obstacle-rich environments makes the claim of "preserving pre-trained knowledge" somewhat tenuous.

The recovery guarantee for a finite number of steps relies on assumptions such as a uniform positive lower bound for safety gradients, local smoothness, and a sufficient iteration budget—none of which have been empirically verified. Furthermore, the relationship between the fixed value of K=10K=10 and the theoretically required budget remains unclear. More importantly, this guarantee applies specifically to predicted action chunks and a defined geometric model; it does not directly account for real-world execution errors or dynamic obstacles.

Each correction step in NSC requires backpropagation through the entire generation process, potentially involving multiple forward passes and line searches. The paper fails to report metrics such as end-to-end latency, GPU memory usage, average iteration counts, or the frequency of timeouts. In contrast, SFM limits its prediction and correction steps based on a fixed number of model evaluations; consequently, it is difficult to discern whether the observed performance gains stem from optimization within the noise space or simply from the additional computational budget.

The existing comparisons simultaneously alter the correction space, the look-ahead horizon, and the total computational effort. Baselines such as optimization over the full action-chunk space, stochastic noise resampling, and gradient-based optimization of raw noise are necessary to determine whether the benefits arise from noise parameterization, safety evaluation of action chunks, or iterative search.

The experiments assume known obstacle geometry, treating obstacles as static within each action chunk, while the robot’s future trajectory is predicted based on its control commands. In scenarios involving dynamic obstacles, control tracking errors, or object manipulation, these approximations may lead to discrepancies between predicted safety and actual safety. Moreover, the collision-avoidance rate in the experiments is notably below 100%, necessitating a systematic analysis of the sources of these residual collisions.

There is an inconsistency regarding the evaluation scope of VLA-Arena: the main text mentions levels L0–L2, while the appendix specifies L1 and L2—and still contains a "TBDepisodes" placeholder. Furthermore, the real-world experiments consist of only 10 trials, all of which involve the base policy following a hazardous path; this demonstrates, at best, a conditional capacity for correction, which is insufficient to substantiate consistent performance gains in general deployment scenarios.

Questions for authors

How can it be verified that the noise-based correction preserves the original behavior of the policy? Could you report the changes in noise distance, norm, or probability—both before and after optimization—and compare task performance as well as action deviations in obstacle-free scenarios?

To what extent does the actual algorithm satisfy the theoretical conditions? Please report metrics such as the safety gradient norm, convergence behavior across iterations, the proportion of cases that remain unsafe even after K=10K=10 iterations, and the specific fallback mechanisms triggered in scenarios involving zero gradients, exhausted budgets, or line-search failures.

What is the practical computational cost of the proposed method? Could you provide the average and high-percentile latency, GPU memory usage, and the number of forward/backward passes for each backbone architecture? Additionally, please include baseline comparisons based on equivalent time or computational budgets.

What is the distinct advantage of performing optimization within the noise space? Could you provide comparative results against alternative approaches, such as safety filtering following random resampling, standard gradient-based optimization, or optimization performed directly in the action space using the same holistic safety function?

What are the primary sources of residual collisions? Please distinguish between errors stemming from predictive models, dynamic obstacles, limited optimization budgets, and geometric modeling inaccuracies. Furthermore, explain how the future geometry of the robotic arm’s links and the objects being manipulated is calculated and incorporated into the safety function.

9 comments

We thank the reviewer for the detailed examination of our method and experiments and the helpful suggestions. We would like to address their concerns and questions below.

(W1 & Q1) Preservation of the pre-trained behavior

The optimized noise may deviate from the high-probability regions encountered during training or standard sampling; thus, actions generated via the original policy are not guaranteed to remain within the realm of familiar or high-quality behaviors. The current lack of analysis regarding noise drift, noise probability, and performance in obstacle-rich environments makes the claim of "preserving pre-trained knowledge" somewhat tenuous.

How can it be verified that the noise-based correction preserves the original behavior of the policy? Could you report the changes in noise distance, norm, or probability—both before and after optimization—and compare task performance as well as action deviations in obstacle-free scenarios?

We agree that the claim of "preserving pre-trained knowledge" is somewhat overstated, because regenerating the actions with the frozen policy does not guarantee it in theory. We will tone down the wording and state instead that NSC stays closer to the learned behavior than the baselines. To support this, we measured the energy distance [1] between each method's executed actions and the policy's samples at the same states.

Energy Distance between Executed Actions and the Policy's Samples (lower is closer).

MethodSafeLIBERO ObjectVLA-Arena StaticObstaclesSafeDetour Toaster
NSC0.030.070.01
SFM0.680.550.84
VLSA1.970.210.12
Direct full-chunk optimization0.310.180.09

The energy distance of NSC is close to 0 in all three settings, so its executed actions are almost indistinguishable from the policy's own samples, while those of the other methods are farther in every setting. Thus NSC stays closer to the learned behavior than the baselines. The details of the computation will be added to Appendix G.2 of the revised manuscript.

We also report the noise statistics that the reviewer requested, before and after the optimization.

Noise Statistics before and after Correction.

SettingDistance moved, ‖z* − z₀‖ / √dNorm before, ‖z₀‖ / √dNorm after, ‖z*‖ / √dChange in log-probability per dimension
SafeLIBERO Object0.2790.9991.054-0.036
VLA-Arena StaticObstacles0.2171.0001.040-0.022
SafeDetour Toaster0.1750.9981.021-0.016

In our experiments, the corrected noise stays close to the initial noise. It moves much less than the distance between two independent samples from the Gaussian prior, and its norm and its log-probability change only slightly. These results indicate that the optimized noise remained close to typical samples of the prior in these settings. They include level L2 of VLA-Arena StaticObstacles, which has two obstacles on the path instead of one. In obstacle-free scenarios, every proposed chunk is already safe, so NSC returns it unchanged. Thus the action deviation is exactly zero, and the task performance is identical to that of the base policy.

References

[1] Székely, G. J. and Rizzo, M. L. Energy statistics: A class of statistics based on distances. Journal of Statistical Planning and Inference, 2013.

(W2-1 & Q2) Empirical verification of the theoretical guarantee

The recovery guarantee for a finite number of steps relies on assumptions such as a uniform positive lower bound for safety gradients, local smoothness, and a sufficient iteration budget—none of which have been empirically verified. Furthermore, the relationship between the fixed value of K=10 and the theoretically required budget remains unclear.

To what extent does the actual algorithm satisfy the theoretical conditions? Please report metrics such as the safety gradient norm, convergence behavior across iterations, the proportion of cases that remain unsafe even after K=10 iterations, and the specific fallback mechanisms triggered in scenarios involving zero gradients, exhausted budgets, or line-search failures.

We agree that these assumptions (Eq. 16 of Prop. A.1) were not verified empirically. We measured the requested metrics on all corrections in the three settings.

Verification of the Theoretical Conditions (K = 10).

SettingCertified (%)Gradient norm (median)Zero gradient (%)Line-search failure (%)Updates (mean)Updates (max)Unsafe after K updates (%)
SafeLIBERO Object99.750.003300.251.4180
VLA-Arena StaticObstacles97.950.00350.161.892.43100
SafeDetour Toaster1000.0025001.3390

Correction ends with a certified chunk in at least 97.95% of the cases, so the three assumptions hold in almost all corrections. The gradient lower bound fails only with a zero gradient (Appendix C.1), which rarely occurs. The local smoothness is needed only for the step size, and the Armijo line search (Appendix B.6) checks the progress inequality in Eq. (20) at every update and rarely fails to find such a step. The iteration budget is sufficient, since correction converges within a few updates on average and no case remains unsafe after K = 10 updates.

The fixed value of K follows from the bound of Prop. A.1. With η = 0.5 and δ = 0.01, this bound is 10 updates for an initial violation of 15 cm, which is the average width of the obstacles in our experiments.

With a zero gradient, an exhausted budget, or a line-search failure, NSC does not execute the chunk and outputs the stop action for that chunk. Thus a failure of the assumptions stops the robot but does not make an executed chunk unsafe. We will add the details of this analysis to Appendix B.8 of the revised manuscript and state the fallback in Algorithm 1.

(W3 & Q3) Computational cost

Each correction step in NSC requires backpropagation through the entire generation process, potentially involving multiple forward passes and line searches. The paper fails to report metrics such as end-to-end latency, GPU memory usage, average iteration counts, or the frequency of timeouts.

What is the practical computational cost of the proposed method? Could you provide the average and high-percentile latency, GPU memory usage, and the number of forward/backward passes for each backbone architecture?

We appreciate this concern and agree that the practical computational cost should be reported. As the reviewer notes, each update needs one backward pass through the generation process and the forward passes of the line search. This cost arises only when the proposed chunk is unsafe, so we report both the average latency over all queries and the average latency over the corrected queries. The cost is measured on SafeLIBERO Object for π0.5 and GR00T N1.7 and on SafeDetour Toaster for Xiaomi-Robotics-1.

Cost of NSC for Each Backbone.

BackboneMethodLatency, mean (ms)Latency, 99th percentile (ms)Peak GPU memory (GB)Forward passesBackward passes
π0.5Base1382086.410
VLSA1452156.410
SFM1712126.410
NSC, all queries1995816.65.80.3
NSC, corrected queries3626946.619.01.4
GR00T N1.7Base90936.010
VLSA971006.010
SFM1231276.010
NSC, all queries1595896.14.70.3
NSC, corrected queries3265946.117.01.3
Xiaomi-Robotics-1Base1741799.810
VLSA2202379.810
SFM3033339.810
NSC, all queries32899210.17.50.3
NSC, corrected queries697109910.125.81.3

For NSC, the table reports both the average over all queries and the average over the corrected queries. VLSA and SFM use only the forward passes of the base policy, without any backward pass. Correction takes only a few updates on average and never exhausts the budget of K = 10, so there was no timeout caused by the budget.

Baseline Comparison under an equivalent budget

In contrast, SFM limits its prediction and correction steps based on a fixed number of model evaluations; consequently, it is difficult to discern whether the observed performance gains stem from optimization within the noise space or simply from the additional computational budget.

Additionally, please include baseline comparisons based on equivalent time or computational budgets.

To verify that the gains do not come from the additional computational budget, we compared NSC with SFM under matched latency. We increased the number of correction steps of SFM until its latency matched the worst-case latency of a corrected query of NSC. Since SFM uses this budget at every query, its total computation is larger than that of NSC. VLSA is not included, because it has no iterative component that can use additional computation. The detailed setup will be added to Appendix G.3 of the revised manuscript.

Comparison Under Matched Latency (TSR / CAR / SS).

MethodSafeLIBERO ObjectVLA-Arena StaticObstaclesSafeDetour Toaster
NSC86 / 88 / 7757 / 83 / 5691 / 99 / 91
SFM (matched to the worst-case latency of NSC)78 / 85 / 6948 / 81 / 4472 / 99 / 72

The gains persist under matched latency in all three settings. Noise resampling under the same budget as NSC also achieves a lower SS than NSC in all three settings, as reported under (W4 & Q4). Thus the gains do not come from the additional computational budget.

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

The paper proposes Noise Safe Corrector (NSC), which optimizes the initial noise of a frozen VLA policy to enforce safety constraints over an entire action chunk, with finite-step safety recovery guarantees under stated assumptions. Experiments across simulated environments and a real robot demonstrate improved trade-offs between collision avoidance and task completion.

Critical strengths
  • Relevant methodological approach. Correcting noise and regenerating the full action chunk provides a principled way to coordinate avoidance across timesteps without policy retraining, potentially reducing deadlocks caused by local action corrections.

  • Conditional theoretical support. The paper derives a closed-form correction and establishes conditions for safety recovery under both continuous-time and discrete updates, providing a theoretical basis beyond empirical heuristics.

  • Broad empirical evaluation. Experiments cover three simulated environments, multiple policy backbones, and a real robot. SafeDetour directly tests detour capability, with average safe success increasing from 41% for the strongest baseline to 67%, supporting the central motivation.

Critical weaknesses
  • The sources of improvement are not sufficiently isolated. NSC combines chunk-level safety evaluation, noise-space optimization, and repeated generation without ablations separating their contributions. Generating actions through a frozen policy also does not ensure that corrected outputs remain in high-probability regions of its behavior distribution.

  • A gap remains between theoretical and execution safety. The guarantees concern a predicted safety function and depend on gradient nondegeneracy, step-size, and iteration-budget conditions. Approximate motion prediction and obstacle geometry held fixed within each chunk limit their applicability to physical execution. The 60% average collision-avoidance rate on VLA-Arena supports improved safety rather than a general safety guarantee (Table 2; Appendices A–B).

  • Evidence for computational fairness and real-world generalization is limited. Repeated generation and backpropagation introduce additional computation, but matched-budget comparisons and latency measurements are missing. The real-robot study includes only ten trials on one task, with both routes demonstrated during training and evaluation restricted to initially unsafe proposals, primarily supporting a controlled mechanism demonstration (§5.5; Appendices B.5–B.7).

Questions for authors
  1. Could the authors compare against direct full-chunk optimization, remove the noise-reference regularization, and include matched-budget resampling to isolate the contributions of lookahead, noise parameterization, and additional search?

  2. How do the adaptive step sizes and fixed ten-update budget relate to the theoretical sufficient conditions? What is the correction failure rate, what happens upon failure, and what explains discrepancies between predicted safety and execution collisions?

  3. Do the gains persist under matched inference latency? Could the evaluation include more real-world tasks, detours without dedicated demonstrations, and uncertainty in obstacle estimates?

6 comments

We thank the reviewer for the thoughtful assessment of our work and the constructive suggestions for strengthening the paper. We would like to answer their questions and concerns below.

(W1-1 & Q1) Ablation

The sources of improvement are not sufficiently isolated. NSC combines chunk-level safety evaluation, noise-space optimization, and repeated generation without ablations separating their contributions.

Could the authors compare against direct full-chunk optimization, remove the noise-reference regularization, and include matched-budget resampling to isolate the contributions of lookahead, noise parameterization, and additional search?

We appreciate this concern and agree that the original comparison did not separate the three factors. As the reviewer suggested, we conducted the three requested experiments, which are direct full-chunk optimization, matched-budget noise resampling, and NSC without the noise-reference term. The detailed setup will be added to Appendix G.1 of the revised manuscript.

Ablation Results (TSR / CAR / SS).

MethodSafeLIBERO ObjectVLA-Arena StaticObstaclesSafeDetour Toaster
Direct full-chunk optimization82 / 78 / 7049 / 62 / 3885 / 78 / 70
Noise resampling (same budget)78 / 33 / 3052 / 72 / 4488 / 41 / 38
NSC w/o the noise-reference term83 / 78 / 7554 / 81 / 5286 / 99 / 86
NSC86 / 88 / 7757 / 83 / 5691 / 99 / 91

Starting from NSC, removing the noise-reference term reduces the SS by 3.7 points on average. Removing the noise parameterization (direct full-chunk optimization) reduces it by 15.3 points. Replacing the CBF-QP update with resampling under the same budget reduces it by 37.3 points. In addition, direct full-chunk optimization improves the SS over VLSA in Tables 1 to 3 of the manuscript by 11.3 points, which shows the benefit of the lookahead. These results show that each component makes its own contribution. We will include this ablation in the revised manuscript.

(W1-2) Behavior distribution

Generating actions through a frozen policy also does not ensure that corrected outputs remain in high-probability regions of its behavior distribution.

We agree that our claim of preserving the learned behavior is somewhat overstated, since regeneration by the frozen policy does not guarantee it theoretically. We will tone down the wording and instead state that NSC stays closer to the learned behavior than the baselines. To support this, we measured the energy distance [1] between each method's executed actions and the policy's samples at the same states.

Energy Distance between Executed Actions and the Policy's Samples (lower is closer).

MethodSafeLIBERO ObjectVLA-Arena StaticObstaclesSafeDetour Toaster
NSC0.030.070.01
SFM0.680.550.84
VLSA1.970.210.12
Direct full-chunk optimization0.310.180.09

The energy distance of NSC is close to 0 in all three settings, so its executed actions are almost indistinguishable from the policy's own samples, while those of the other methods are farther in every setting. Thus NSC stays closer to the learned behavior than the baselines. The details of the computation will be added to Appendix G.2 of the revised manuscript.

References

[1] Székely, G. J. and Rizzo, M. L. Energy statistics: A class of statistics based on distances. Journal of Statistical Planning and Inference, 2013.

(W2 & Q2) Gap between theoretical and execution safety

We agree that there is a gap between theoretical and execution safety. To address this gap, we first explain how the conditions that the guarantee depends on (Prop. 4.1 and Prop. A.1) are chosen and why. We then analyze when these conditions hold and when they do not (Appendix C.1), and explain the collisions that remain even when they hold (Table 2). Finally, we describe how the limitations of the fixed obstacle geometry and the approximate motion prediction (Appendix B.1) can be mitigated.

Theoretical conditions and failure

The guarantees concern a predicted safety function and depend on gradient nondegeneracy, step-size, and iteration-budget conditions.

How do the adaptive step sizes and fixed ten-update budget relate to the theoretical sufficient conditions?

What is the correction failure rate, what happens upon failure, [...]

These conditions (Eq. 16 of Prop. A.1) decide whether a safe chunk is found within K updates, not whether an executed chunk is safe, which follows from the acceptance test h(A) ≥ 0 in Algorithm 1 alone. Gradient nondegeneracy is needed for the QP to have a solution (Appendix C.1). The step size does not need to be fixed, because the Armijo line search (Appendix B.6) checks the progress inequality in Eq. (20), H(zk+1)−H(zk)≥σ ηk (δ−H(zk))H(z_{k+1}) - H(z_k) \ge \sigma\,\eta_k\,\bigl(\delta - H(z_k)\bigr), at every update. We will add this result as Prop. A.2 (Appendix A.3). We chose K = 10 from the bound of Prop. A.1. With η = 0.5 and δ = 0.01, this bound is 10 updates for an initial violation of 15 cm, which is the average width of the obstacles in our experiments. The table below reports the ratio of certified corrections, the number of updates, and the causes of correction failure. We will add the details to Appendix B.8 of the revised manuscript.

Convergence and Failures of NSC (K=10).

SettingCertified (%)Updates (mean)Updates (max)Budget exhausted (%)Zero gradient (%)Line-search failure (%)
SafeLIBERO Object99.751.418000.25
VLA-Arena StaticObstacles97.952.431000.161.89
SafeDetour Toaster1001.339000

When correction fails, NSC does not execute the chunk and outputs the stop action for that chunk. We will state this behavior in Algorithm 1.

Predicted and executed safety

The 60% average collision-avoidance rate on VLA-Arena supports improved safety rather than a general safety guarantee (Table 2; Appendices A–B).

[...] what explains discrepancies between predicted safety and execution collisions?

Approximate motion prediction and obstacle geometry held fixed within each chunk limit their applicability to physical execution.

We would like to clarify the scope of the guarantee. The safety function (Appendix B.1) is defined on the gripper and the wrist link (link 7), so a chunk returned by NSC keeps these two bodies at least ε away from the obstacles. To explain the discrepancies, we analyzed which body is involved in the remaining collisions of certified chunks.

Remaining Collisions of Certified Chunks.

SuiteLinks 0 to 6 (%)Grasped object (%)Gripper or wrist link, prediction error (%)Gripper or wrist link, obstacle motion (%)
SafeLIBERO Object17.162.520.40
VLA-Arena StaticObstacles7.872.319.90
VLA-Arena DynamicObstacles12.245.824.117.9
SafeDetour Toaster100000

In all four suites, most of the remaining collisions occur at the grasped object or at links 0 to 6, which the guarantee does not cover. With static obstacles, the collisions occur either at the bodies that the guarantee does not cover or because of the error of the predictive model. With dynamic obstacles, the bodies that the guarantee covers can also collide because of the obstacle motion.

However, these collisions can be mitigated by a per-step safety check, which evaluates the remaining part of the chunk again before each action is executed. We did not use it in the reported experiments for a fair comparison with the baselines. We report the results with the per-step safety check below. The details will be added to Appendix G.4 of the revised manuscript.

Effect of the Per-step Safety Check (TSR / CAR / SS).

MethodSafeLIBERO ObjectVLA-Arena StaticObstaclesVLA-Arena DynamicObstaclesSafeDetour ToasterLatency per corrected query (ms)
NSC86 / 88 / 7757 / 83 / 5644 / 72 / 3791 / 99 / 91480
NSC with the per-step check85 / 96 / 8465 / 91 / 6241 / 89 / 4092 / 100 / 92483

The per-step check improves the CAR and SS, while the latency per corrected query changes only from 480 ms to 483 ms. Thus this limitation can be mitigated, and we will add this option and these results to the revised manuscript.

(W3 & Q3) Computational cost & Real-world evaluation

Computational cost

Evidence for computational fairness and real-world generalization is limited. Repeated generation and backpropagation introduce additional computation, but matched-budget comparisons and latency measurements are missing.

Do the gains persist under matched inference latency?

We appreciate this concern and agree that the latency should be reported. To verify that the gains do not come from the additional computation, we compared NSC with SFM under matched latency. SFM is given the worst-case latency of a corrected query of NSC, so its total computation is larger than that of NSC. VLSA is not included, because it has no iterative component that can use additional computation.

Comparison Under Matched Latency (TSR / CAR / SS).

MethodSafeLIBERO ObjectVLA-Arena StaticObstaclesSafeDetour Toaster
NSC86 / 88 / 7757 / 83 / 5691 / 99 / 91
SFM (matched)78 / 85 / 6948 / 81 / 4472 / 99 / 72

The gains persist under matched latency in all three settings. Thus the gains of NSC do not come from the additional computation. The latency of each method and details of matched latency will be added to Appendix G.3 of the revised manuscript.

Real-world evaluation

The real-robot study includes only ten trials on one task, with both routes demonstrated during training and evaluation restricted to initially unsafe proposals, primarily supporting a controlled mechanism demonstration (§5.5; Appendices B.5–B.7).

Could the evaluation include more real-world tasks, detours without dedicated demonstrations, and uncertainty in obstacle estimates?

We intended the original real-world study to assess whether each method can detour toward the safe route after an unsafe proposal. For this reason, both routes were demonstrated and only episodes with an unsafe proposal were evaluated. We agree that this evaluation alone is not sufficient. To cover more diverse real-world settings and uncertainty in obstacle estimates, we conducted an additional real-world experiment in which new obstacles, which were not seen during training, are perceived by a VLM. We used three obstacles, a small cup, a medium mug, and a large tumbler, which require obstacle avoidance, a detour, and a more restricted detour, respectively. Each method is evaluated over 20 episodes per obstacle, and every episode is included regardless of the route that the base policy proposes.

Real-World Results with diverse obstacle and VLM perception (TSR / CAR / SS).

MethodSmallMediumLarge
Base65 / 50 / 5095 / 70 / 6595 / 60 / 60
SFM95 / 100 / 95100 / 65 / 6560 / 80 / 40
VLSA55 / 60 / 5065 / 100 / 6560 / 60 / 60
NSC95 / 100 / 95100 / 100 / 100100 / 100 / 100

Even with perception errors, NSC achieves the highest safe success for the medium and large obstacles and the same safe success as SFM for the small obstacle. Thus the advantage of NSC holds with more diverse obstacles and uncertain obstacle estimates. We will add this experiment to Section 5.5 and its detailed setup to Appendix B.5 of the revised manuscript.

Comments on the paper

2 comments
AuthorsOpenReview ↗

General response to reviewers

We sincerely thank all reviewers for their thoughtful and constructive comments. We appreciate their recognition of our paper's strengths, including

  1. Training-free noise-space correction that coordinates actions across the entire chunk (sLEc, TpB5, 1v4P).
  2. Anticipation of later hazards and selection of safe detours, addressing the stagnation associated with local corrections (TpB5).
  3. Closed-form CBF-QP updates without a general-purpose QP solver (TpB5).
  4. Conditional safety-recovery guarantees in both continuous and discrete time (sLEc, TpB5, 1v4P).
  5. Broad empirical evaluation across simulation environments, multiple VLA backbones, and a real robot (sLEc).
  6. Improved safe task completion over baseline filters (sLEc, TpB5, 1v4P).

In response to the reviewers' feedback, we have conducted additional experiments and updated our paper, as summarized below. All revisions are marked in red in the revised manuscript.

Additional Experiments and Analyses

  • Component ablations and additional baselines. We evaluate full-chunk action-space optimization, matched-budget noise resampling, plain gradient-based noise optimization, and NSC without the noise-reference term. NSC achieves the highest safe success across all three evaluated settings, exceeding full-chunk action-space optimization by 15.3 percentage points on average. (Appendix G.1, Table 9)
  • Computational cost and matched-latency comparison. We report latency, peak GPU memory, forward/backward passes, line-search evaluations, and correction counts across all three backbones. NSC retains a 13.0 point average safe-success advantage over SFM when SFM is allocated the worst-case latency of an NSC corrected query. (Appendix G.3, Tables 12 to 14)
  • Behavior-distribution analysis. We report noise displacement, norms, and changes in prior log-probability, together with the energy distance between executed actions and policy samples. NSC yields lower energy distances than SFM, VLSA, and direct full-chunk optimization in all three evaluated settings. (Appendix G.2, Tables 10 and 11)
  • Convergence and correction failures. We report safety-gradient norms, correction iterations, and failure causes. Across the three evaluated settings, 97.95% to 100% of correction attempts produce a certified predicted chunk, with no failures due to exhaustion of the ten-update budget. (Appendix B.8, Table 8)
  • Residual collisions and per-step safety checks. We distinguish collisions involving bodies outside the safety model from those caused by motion-prediction errors or obstacle motion. Rechecking the remaining chunk before each action increases average collision avoidance from 85.5% to 94.0% across four evaluated suites. (Appendix G.4, Tables 15 and 16)
  • Expanded real-robot evaluation. We evaluate three previously unseen obstacles with VLM-based perception over 20 episodes per obstacle per method, including episodes regardless of the initially proposed route. NSC achieves safe success rates of 95%, 100%, and 100% for the small, medium, and large obstacles, respectively. (Section 5.5, Table 5, and Appendix B.5)

Paper Revisions

  • Additional ablations. We add the four ablation comparisons and their experimental setups, which distinguish the contributions of chunk-level lookahead, noise-space correction, and additional search (Appendix G.1, Table 9), revise the description of the baseline failures (Section 5.2), and refer to the ablation from Section 5.3.
  • Computational cost. We add latency and GPU-memory measurements, forward/backward and Armijo evaluation counts, and correction-count distributions across three backbones, reporting all queries and corrected queries separately. (Appendix G.3, Tables 12 and 13)
  • Comparisons under matched budgets. We include the full-chunk optimization and noise-resampling comparisons under the same safety score and budget (Appendix G.1, Table 9), together with the latency-matched SFM results and the details of budget allocation (Appendix G.3, Table 14).
  • Behavior-distribution analysis and claims. We add the noise statistics and energy-distance comparisons and explain their computation (Appendix G.2, Tables 10 and 11). We tone down the claim of preserving pretrained behavior to what the empirical evidence supports, since it is not guaranteed in theory (Abstract, Section 1, and Section 5.2).
  • Adaptive correction analysis. We extend the recovery analysis to adaptive Armijo updates under stated conditions (Appendix A.3, Proposition A.2) and clarify the relationship between the recovery bound and the ten-update budget (Appendices B.6 and B.8).
  • Convergence and failure diagnostics. We add safety-gradient norms, certification rates, correction iterations, and the frequencies of near-zero gradients, line-search failures, and budget exhaustion. (Appendix B.8, Table 8)
  • Residual-collision analysis. We add the breakdown of collisions involving excluded robot links and grasped objects, motion-prediction errors, and obstacle motion to explain the gap between predicted and executed safety. (Appendix G.4, Table 15)
  • Safety model and guarantee scope. We expand Appendix B.1 with the gripper/wrist geometry, motion prediction, excluded links and grasped objects, and obstacle geometry held fixed within each chunk (Eqs. 25 to 28). We distinguish predicted certification from safety during physical execution (Appendix B.1, "Scope of the guarantee", referred to from Proposition 4.1, and Section 6).
  • Implementation and fallback behavior. We specify the softmin surrogate, hard-minimum acceptance test, and temperatures (Appendix B.1), and the CBF margin and parallel Armijo rule (Appendix B.6). Algorithm 1, Section 4.2, and Appendix C.1 explicitly state that failed correction triggers a stop action without executing the uncertified chunk. Already-safe proposals are returned unchanged (Section 4.2).
  • Per-step safety-check experiments. We add the per-step checking option and its performance and latency results. We describe how the remaining chunk is checked using updated robot states and obstacle geometry, with a new policy query triggered when the check fails. (Appendix G.4, Table 16)
  • Additional real-world experiments. We add the results with three unseen obstacles and VLM-based perception to Section 5.5 (Table 5) and their detailed setup to Appendix B.5. We document the 20 episodes per obstacle per method and shared initial states, and distinguish this evaluation including all proposals from the original study restricted to unsafe proposals.
  • Evaluation protocol and notation. We correct Section 5.3 and Appendix B.3.2 to specify VLA-Arena L1/L2 with ten episodes per task and use a consistent safety-margin convention throughout (Appendices B.1, B.6, and E).

We sincerely thank the reviewers again for their constructive feedback and hope these additions and revisions address their concerns.

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

Related papers

Loading the map…

Discussion (0)

Sign in to comment.