acceptodds
Under review as a conference paper at ICLR 2027

A Training-Free Approach for Adapting Flow-Matching Policies to Spatial Shifts

Abstract

A deployed pre-trained policy often has to operate in a fixed spatial layout that differs from the one it was trained on. This spatial shift places the policy outside its training distribution, where it frequently fails. We seek a training-free adaptation that raises the success rate at run time using only the policy's own attempts at that layout: no demonstrations, no weight updates, only the outcomes of its own attempts. A success recorded there represents a complete trajectory that solves the layout; with the weights frozen, that trajectory can only be exploited through the sampler. For a chunked flow-matching policy, the sampler offers three entry points: the measure it starts from, the time at which it enters the flow, and the action it emits. We inject the stored success at all three points. Specifically, warm-started denoising re-enters the flow from the success under the current observation; a density gate, using the density defined by the same velocity field, returns control to the policy once the re-solved chunk is no longer one the policy would produce; and an action-space residual search adds a constant offset fitted using terminal outcomes alone. We consolidate these into WDRS, a plug-and-play adaptation framework, and conduct extensive empirical validation. On LIBERO, WDRS raises single-draw success from to at the smallest of three jitter scales and matches or exceeds a per-site weight-update baseline in five of six suite-by-jitter cells; it carries over to two further frozen flow policies (up to ), and to the Layout perturbations of LIBERO-plus () and RoboLab (, warm-started only). This demonstrates that WDRS is a highly transferable and readily deployable solution.

Primary area:
applications to robotics, autonomy, planning
Keywords:
Vision–Language–Action, Flow-Matching, Generative Policy

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_FMBCOpenReview ↗
Rating
3(+1)
Confidence
3
Informativeness
2
Presentation
2
Soundness
2
Read review
Paper summary

WDRS is a training-free site adaptation method: it reuses the intermediate state of a successful trajectory from the frozen flow strategy, re-solves the sampled trajectory under the current observation, uses density gating to determine when to hand over control, and fits the motion space constant offset with the success label to correct the fixed spatial offset of the deployment station.

Critical strengths

Overall, the paper is clearly motivated and well structured. The writing is clear, and the authors provide thorough experimental analyses to support and validate the proposed approach.

Critical weaknesses
  1. The method only works for small-to-moderate jitter on a fixed site. Layouts that change across deployments, large non-persistent shifts, and multiple heterogeneous sites are not covered.

  2. The frozen policy must succeed at least once at the site. If it never does, the method cannot start, and boarding can be expensive when success is rare.

  3. The paper gives default values for the gate threshold, warm-up length, and CEM settings, but there is little evidence that these hold across backbones and tasks.

  4. The paper does not give matched-compute comparisons of wall-clock time, memory, or total inference cost against the frozen policy and training-free baselines.

  5. Only simulated benchmarks are used, with no real-robot validation.

Questions for authors

Please see the weaknesses.

5 comments

W1

We thank the reviewer for the detailed suggestion. We think that in practical deployment, large shifts that are random and non-persistent are rare. For example, in a household, the positions of the microwave or a bowl do not change drastically from one episode to the next, but small displacements are present every time. Moreover, a fully random large shift is inherently hard to adapt to at deployment time without demonstrations, unless the base policy is already sufficiently robust or an additional strongly generalizing supervision module is introduced. We therefore decompose such shifts into small-scale shifts and address them within that small range. This is the point Figure 1 is meant to illustrate.

The case of multiple large shifts (i.e., multiple sites) can be handled by adding a retrieval layer on top of our method, as discussed in RTS (retrieve-and-steering). The matching WDRS memory (tape and offset) is retrieved by similarity, so each site reuses its own adapted solution. We will add this discussion as an extension of WDRS in the paper.


W2

As the reviewer notes that the method needs a success before it can be activated, this is precisely the question we set out to answer: what can occasional successes bring to a deployed policy?

We do not aim to improve generalization or robustness through data augmentation or through repeated interaction during pre-training or post-training. Instead, we consider a trained policy that is deployed on a fixed layout subject to an unknown spatial shift. Our method is a plug-in: it uses no demonstrations and performs no weight updates. Without it, the policy simply runs exactly as deployed.

Nearly all of our baselines, including fine-tuning, RL, and steering, also require successful trajectories to work. This is a basic requirement for this class of methods, not one specific to ours. Our method needs fewer successes than these baselines. Ws needs only a single successful trajectory. RS does not even require a tape: it needs only one perturbed attempt during its search to succeed, so it can bootstrap from a near-zero SR. For example, on one GR00T site the frozen policy succeeds in 0/15 trials, while RS alone reaches 10/15. By contrast, fine-tuning-based methods require considerably more successful trajectories. Table 1 compares the sample efficiency of all methods under the same budget.

When the policy never succeeds at a site, Ws and Dg are never invoked, and the policy runs natively. In this case, only demonstration-based approaches (e.g., in-context methods) can work efficiently without extra exploration. In practice, however, collecting demonstrations for every possible spatial shift is infeasible. We consider this case outside the scope of our work. It calls for a better base model or additional training data.


W3

Apart from the integration start t0t_0, every hyperparameter was held fixed across all three backbones (π0.5\pi_{0.5}, GR00T N1.7, πRL\pi_{\mathrm{RL}}), both LIBERO suites, all three jitter levels and LIBERO-plus: the gate quantile q=0.08q=0.08, the warm-up (10 attempts, pool of at least 40 chunks), the density estimator (50 reverse steps, 2 reference samples, 1 probe) and the CEM settings (4×154\times15 attempts, s0=0.02s_0=0.02, smin⁡=0.006s_{\min}=0.006, shrink 0.850.85, clip 0.060.06). Only t0t_0 was recalibrated per backbone because the backbones use different numbers of integration steps (§4).

We parameterise the gate by a within-site quantile rather than an absolute log-density, precisely because absolute values do not transfer: the median threshold is −435-435, −458-458 and −48-48 nats on the three backbones. A quantile is invariant to these offsets, and the realised firing rate tracks qq.


W4

We thank the reviewer for the suggestion. We have compared the computational efficiency and memory footprint of all baselines, with all models run in FP32. The results are shown in the table below:

MethodDeployment (s / 100 steps)× frozenMemoryExtra storage
Frozen policy3.241.014570 MB—
Open-loop replay0.62--tape(s)
Golden ticket / Latent-noise search3.241.014570 MBtape(s) / one seed / one vector
RTS3.35≈ 1.014570 MBtape(s) / one seed / one vector
Per-site LoRA3.251.015202 MB7 GB merged model per site
WDRS7.262.215088 MBone tape + Δ ∈ ℝ⁶

Our method stores only a small amount of intermediate state, so it adds roughly 500 MB of memory. WDRS computes a density gate to decide when to hand over, which requires two additional reverse ODE integrations. As a result, its end-to-end latency is about 2.2× that of the frozen policy.

The 2.2× overhead applies only while the method is still optimizing. Once optimization is complete, the tape is fixed, and the offset has been estimated, so the density gate can be replaced by a constant gate. Inference latency then returns to the same level as the frozen policy.

W5

Thanks for the comments. To validate the practicality of our method on a physical robot, we deployed the full framework on a Franka Panda. Following the DROID platform, we use two cameras (wrist and external). Our base model is π0.5-DROID, which we fine-tuned to calibrate for our camera viewpoints and gripper. We will release all hardware components, model configurations, and checkpoints with the paper. We evaluate on two tasks: (1)“pick up the banana and put it into the bowl” and (2)“pick up the black cube and put it on the white paper.” We ran 4 experimental groups, each with a different angular perturbation, and evaluated each group over 16 trials. The results are as follows:

Method#1#2#3#4Total
Frozen Policy5/167/165/168/1625/64 = 0.391
Open-loop Replay2/163/161/163/169/64 = 0.140
Ws7/168/168/166/1629/64 = 0.453
Ws+Dg7/168/169/167/1631/64 = 0.484
RS9/1610/168/168/1635/64 = 0.547
WDRS11/168/1610/1611/1640/64 = 0.625

WDRS improves the success rate by about 23.4% over the frozen policy, consistent with our findings in simulation. We also observe that the gain from replay is smaller than in simulation. This is because the real-world policy experiences more disturbances, and outcomes are more sensitive to collisions than in simulation. We are working on continually evaluating more tasks to further validate the practicality of the method.

We further evaluated two additional physical robot tasks: “pick up the bottle and put it on the white paper” and “pick up the cube or banana and put it into the bowl.” The frozen policy starts from a higher initial SR on these two tasks, and WDRS constantly improves the success rate by about 31%, bringing it close to 100%, as shown following:

Method#1#2#3#4Total
Frozen Policy12/1610/1610/1611/1643/64 = 0.672
Open-loop Replay11/1612/161/1610/1634/64 = 0.531
Ws14/1616/1611/1610/1651/64 = 0.797
Ws+Dg14/1616/1612/1610/1652/64 = 0.812
RS16/1614/1613/1615/1658/64 = 0.906
WDRS15/1616/1616/1616/1663/64 = 0.984
Reviewer_brLAOpenReview ↗
Rating
1
Confidence
2
Informativeness
1
Presentation
2
Soundness
1
Read review
Paper summary

This paper discusses the probelm of how to adapt a pre-trained robotic policy into different deployments, where minor changes may lead to severe performance degradations. This paper proposes WDRS, a training-free method that, reuses the successful rollouts inserting them into the diffusion policy as a base to provide enough hints for the adjustment. However, purely relying on this will lead to an unsatisfied results as small shfits may exist between different attempts. Therefore, the authors also design a gate to verify if the following policy should be based on the hints or not.

Critical strengths
  1. The gate design is critical. It effectively prevents the negative transfer commonly suffered by naive trajectory reuse, releasing control back to the base policy the moment environmental jitter renders the cached prior invalid.
Critical weaknesses

My main concern is about the efficiency and real-robot deployment.

(1) As the approach requires at least one success trajecotry for the replay, there is no enough analysis on how this effects the efficiency. For example, the authors state that the rollout budget is 72 attempts for each task, however for hard tasks it may take 40-50 times to find the first successful rollout (for libero-plus, only half of the tasks make it), then there is no room for subsequent density pool warm-up or CEM residual search. Also, as illustrated by libero-plus, this approach seems not feasible in hard-task as many of them fail to meet the "at-least one successful rollout" requirement.

(2) All experiments are in simulation, no real robots. For a robot policy study, I don't think it is promising enough, especially considering that this paper states "training-free shift adjustment". The real shift in real robot deployment, should be tested at least.

Questions for authors

See weakness.

5 comments

W1

We thank the reviewer for the insightful comment.

Setting. We would first like to clarify the setting we target. We do not aim to improve generalization or robustness through data augmentation or through repeated interaction during pre-training or post-training. Instead, we consider a policy that has already been trained and is deployed at a fixed layout subject to an unknown spatial shift. Our method is not a standalone training method. It is a plug-in that uses no demonstrations and no weight updates, and all of its inputs come from the policy itself. When the deployed policy degrades, the method offers an additional, purely additive way to recover its success rate (SR). Without it, the policy runs exactly as deployed.

On requiring success. That the method needs a success to activate is, in fact, central to the question we study: what can occasional successes bring to a deployed policy? We would also like to highlight three points.

Success is a common prerequisite. Nearly all of our baselines, including fine-tuning, RL, and steering, also require successful trajectories to work. This is a basic requirement for this class of methods, not one specific to ours. Our method needs fewer successes than these baselines. Ws needs only a single successful trajectory. RS does not even require a tape: it needs only one perturbed attempt during its search to succeed, so it can bootstrap from a near-zero SR. For example, on one GR00T site the frozen policy succeeds in 0/15 trials, while RS alone reaches 10/15. By contrast, fine-tuning-based methods require considerably more successful trajectories. Table 1 compares the sample efficiency of all methods under the same budget. The only alternative is demonstrations. When the policy fails completely after deployment, only demonstration-based approaches (e.g., in-context methods) can work efficiently without extra exploration. In practice, however, collecting demonstrations for every possible spatial shift is infeasible.

Cost when the policy never succeeds. If the policy never succeeds at a site, Ws and Dg are never invoked and the policy runs natively. The only cost is logging the attempts, and these attempts are ordinary rollouts that deployment performs anyway, not extra data collected for fine-tuning.

Why we list this as a limitation. If the policy’s true success rate at a site is zero, the native policy itself cannot solve the task there. No deployment-time method without demonstrations or weight updates can help in this case; it calls for a better base model or additional training data. We list this case as a limitation to acknowledge that some corner cases under environmental shifts cannot be easily resolved, and addressing them remains a harder, open problem.

W2

Thanks for the comments. We agree on the necessity of physical robot validation. To validate the practicality of our method on a physical robot, we deployed the full framework on a Franka Panda. Following the DROID platform, we use two cameras (wrist and external). Our base model is π0.5-DROID, which we fine-tuned to calibrate for our camera viewpoints and gripper. We will release all hardware components, model configurations, and checkpoints with the paper. We evaluate on two tasks: “pick up the banana and put it into the bowl” and “pick up the black cube and put it on the white paper.” We ran 4 experimental groups, each with a different angular perturbation, and evaluated each group over 16 trials. The results are as follows:

Method#1#2#3#4Total
Frozen Policy5/167/165/168/1625/64 = 0.391
Open-loop Replay2/163/161/163/169/64 = 0.140
Ws7/168/168/166/1629/64 = 0.453
Ws+Dg7/168/169/167/1631/64 = 0.484
RS9/1610/168/168/1635/64 = 0.547
WDRS11/168/1610/1611/1640/64 = 0.625

WDRS improves the success rate by about 23.4% over the frozen policy, consistent with our findings in simulation. We also observe that the gain from replay is smaller than in simulation. This is because the real-world policy experiences more disturbances, and outcomes are more sensitive to collisions than in simulation. We are working on continually evaluating more tasks to further validate the practicality of the method.

We further evaluated two additional physical robot tasks: “pick up the bottle and put it on the white paper” and “pick up the cube or banana and put it into the bowl.” The frozen policy starts from a higher initial SR on these two tasks, and WDRS constantly improves the success rate by about 31%, bringing it close to 100%, as shown following:

Method#1#2#3#4Total
Frozen Policy12/1610/1610/1611/1643/64 = 0.672
Open-loop Replay11/1612/161/1610/1634/64 = 0.531
Ws14/1616/1611/1610/1651/64 = 0.797
Ws+Dg14/1616/1612/1610/1652/64 = 0.812
RS16/1614/1613/1615/1658/64 = 0.906
WDRS15/1616/1616/1616/1663/64 = 0.984

Dear reviewer, as the discussion period ends today, we wanted to follow up and ask whether our responses have addressed your concerns. If you have any further questions or comments, we would be more than happy to clarify them. We really appreciate your feedback and would be glad to address any remaining concerns.

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

WDRS is a training-free method that adapts a frozen chunked flow-matching robot policy to a fixed spatial layout shift, using only the success/failure of its own attempts. It warm-starts denoising from a stored successful trajectory, stops the injection with a density gate, and adds a constant action offset found by CEM search.

Critical strengths
  • An important problem. As far as I can tell from recent robustness studies, robotics policies often break when objects are simply moved, so the problem shown in Fig. 1 seems both hard and practically important.

  • Practical setting. A fixed workstation with a persistent displacement seems like a realistic deployment case, and needing only binary outcomes (no demos, no gradients) makes the method easy to plug in.

  • Large gains at small jitter, plus honest negative results. The improvements at σ≤1\sigma \le 1 cm look substantial across backbones (Tables 1, 2 and 4), and the appendix reports failure cases and limitations openly (Tables 5, 7, 8).

Critical weaknesses

Please note that I am not an expert in robot learning, so some of the points below may come from my misunderstanding.

  • It is unclear how much Ws and Dg contribute beyond RS. Table 4 adds the components one by one (Ws, then Dg, then RS), and RS gives the largest jump. If I read App. E and Fig. 3(d) correctly, once RS is on, the gate fires in almost every episode and the tape is dropped early. So the deployed method might behave mostly like "frozen policy + a searched constant offset". An RS-only row would make this clear.

  • The Per-site LoRA row in Table 1 looks inconsistent. For all other rows, the number in brackets equals the success rate minus the frozen policy, but not for LoRA (e.g., .247 (+.013) against a frozen .247, and .373 (+.073) against .275). Maybe this is a different paired statistic, but it is not explained.

  • The meaning of a constant action offset is not fully clear to me. If the actions are delta poses, a constant offset acts like a constant velocity bias, and the paper says it does not accumulate as drift because the policy corrects for it (line 266). Also, objects are displaced in different directions (Fig. 4), so I am not sure how one episode-wide offset can help both the pick and the place.

Questions for authors
  • Could you add RS-only and Ws+RS results to Table 4, so that the contribution of Ws and Dg can be separated from RS?

  • Could you clarify how the bracketed numbers in the Per-site LoRA row of Table 1 are computed, and what budget LoRA uses?

  • Is the action space absolute or delta? What do the searched offsets look like, and how do they relate to the site displacement?

  • What is the run-time cost of the density gate per chunk compared with normal sampling?

  • Warm-started denoising seems essentially the same as SDEdit / img2img (re-noise to t0t_0 and denoise under a new condition), only reusing the original noise instead of sampling a new one. Could you clarify what is new here compared with SDEdit?

4 comments

Q1

We thank the reviewer for this valuable suggestion. Following it, we have added the results of RS only and Ws+RS to Table 4. The comparison is shown below:

Methodσ=0.5σ=1.0σ=2.0σ=0.5σ=1.0σ=2.0
Frozen policy.247.275.300.319.311.341
Ws.433 (+.186).373 (+.098).160 (−.140).333 (+.014).281 (−.030).230 (−.111)
Ws + Dg.473 (+.226).393 (+.118).287 (−.013).415 (+.096).341 (+.030).281 (−.060)
Ws + Dg + RS = WDRS.720 (+.473).687 (+.412).467 (+.167).793 (+.474).715 (+.404).400 (+.059)
RS only.653 (+.406).633 (+.358).507 (+.207).748 (+.429).526 (+.215).370 (+.029)
Ws + RS.730 (+.483).620 (+.345).393 (+.093).689 (+.370).611 (+.300).252 (−.089)

We first clarify the cause of the jump. Ws and Dg can improve the SR after a single success, and the gains in the ablation come entirely from that first success. RS works differently. It learns a bias from dozens of accumulated trials, so its improvement builds up gradually over many successes. The results show two things. First, RS only consistently underperforms WDRS, because Ws gives RS a better reference to start from. Second, the Ws+RS results reveal the role of Dg: as σ increases, Dg progressively reduces the reliance on the successful prior, which no longer serves as a valid reference under larger shifts. Without Dg, Ws+RS keeps relying on an outdated reference, so its performance drops more sharply than WDRS as σ grows.


Q2

We thank the reviewer for pointing this out. The numbers in parentheses are paired differences, and they were computed against the wrong baseline. Specifically, each one was computed against the frozen-policy evaluation from the same run as the per-site LoRA. The “Frozen Policy” column, by contrast, reports the average of four independent evaluations, one of which is that same run. This mismatch is why the paired differences do not exactly match the gap between the two columns. We will recompute them against the “Frozen Policy” column for consistency. The corrected gains are +.000/+.098/+.080 (Object) and +.012/+.043/+.085 (Spatial). None of the conclusions in the paper change.

LoRA receives the same 72 attempts per site as the adaptation budget. Collection uses scenes disjoint from the 15 evaluation scenes; all successful rollouts among the 72 are kept as demonstrations, and a rank-8 LoRA is trained for 50 steps (batch 2, lr 10−410^{-4}), merged, and evaluated with the same 300-step horizon.


Q3

Actions are delta end-effector commands: LIBERO's OSC_POSE controller with control_delta=True; each 7-D action is normalised to [−1,1][-1,1] (translation scaled by 0.05 m, axis-angle rotation by 0.5 rad, plus the gripper). Δ∈R6\Delta\in\mathbb{R}^6 is added to the six pose dimensions at every control step; the gripper is never offset, and ∣Δ∣∞≤0.06|\Delta|_\infty\le 0.06. Both base policies run on the same environment and controller.

The learned offsets are small: the median translational norm is 0.0260.026–0.0340.034 (≈1.5 mm of additional commanded motion per step) and the rotational norm 0.020.02–0.0350.035, about half the clip bound, across both base policies and all three jitter levels. Because the command is a delta and the policy is closed-loop, a constant offset does not integrate into unbounded drift: the policy re-observes and partially compensates, and the induced state deviation plateaus within about two chunks.

Relation to the site displacement. The direction of Δ\Delta is a property of the site. Two independent runs at the same site, with different tapes, recover offsets with median cosine 0.860.86, against 0.060.06 between different sites of the same task. Its direction is significantly aligned with the displacement of the target object, whereas a control direction drawn from the same random stream, the basket's displacement, shows no alignment (−0.02-0.02, p=0.90p=0.90). The alignment is partial, however: Δ\Delta is not an estimate of δw\delta_w. A per-step bias of ~1.5 mm is not a 10 cm translation of the trajectory, and roughly 60% of the direction is not explained by the displacement. We read Δ\Delta as a site-specific command correction that is correlated with, but not equal to, the geometric shift.

Q4

Plain sampling of one action chunk with π0.5\pi_{0.5} (K=10K=10 Euler steps, 10 evaluations of vθv_\theta) takes 0.42 s. Scoring that chunk with the density gate requires a reverse integration of the chunk and of two reference samples (50 reverse steps, one Hutchinson probe). We evaluate the chunk, the references and the probe in lock-step as a single batch, so each integration step costs one batched call of vθv_\theta. In this batched implementation the gate adds 0.89 s per chunk. The same batched gate on GR00T N1.7 (K=4K=4) takes 0.94 s per chunk.

The gate is evaluated only on chunks driven by the tape before it fires; after the handoff the policy samples at its native cost, and Ws and Rs add no measurable overhead (a warm-started rollout runs at the frozen policy's speed, and Rs adds a constant to the action).


Q5

We agree that the sampling step of Ws is SDEdit-style: it enters the flow at an intermediate time t0t_0 and integrates to t=0t=0 under a new condition. We will cite SDEdit and state this explicitly in §3.2. The differences between Ws and SDEdit are :

(1) What is being re-solved, and why. SDEdit edits one sample toward a user-provided guide. In our setting the "guide" is a successful trajectory the robot itself produced, and it is re-solved chunk by chunk along a new closed-loop episode, each chunk under the observation actually encountered. The contribution is this use, and its composition with the gate and the residual search, not the denoising step itself.

(2) Ws reusing the recorded path point instead of re-noising. We ran the SDEdit variant (re-noise the stored action with fresh noise to t0t_0, then denoise) as an ablation. On success rate the two are indistinguishable: differences of +0.015±0.021+0.015\pm0.021 and +0.024±0.021+0.024\pm0.021 at t0=0.1t_0=0.1 and 0.50.5 (σ=2\sigma=2, 22 sites), and +0.053±0.026+0.053\pm0.026 at σ=0.5\sigma=0.5 (CI includes 0). But what the path point buys is a well-defined gate statistic. Since it does not introduce a new noise, making the scored chunk a deterministic function of the tape and the observation: two replicate runs give 50/50 identical density values, against 0/50 for the re-noised variant, so the gate's pool reflects variation across scenes rather than sampler noise.

In short, Ws is SDEdit applied to a self-recorded success inside a closed control loop. The path-point base measure is chosen to make the density gate interpretable.

Thanks to authors' careful response, which addressed my concern. As I mentioned I'm not an expert for robotics learning, I would like to maintain my Weak Accept score (3).

Thank you for taking the time to review our paper. Actually, your comments are very helpful and have helped us strengthen the paper a lot. Really appreciate your response and valuable time!

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

Related papers

Loading the map…

Discussion (0)

Sign in to comment.