WorksComputer Science
Task Convergent Flow Matching for Generative Robotics
Abstract
Successful manipulation requires the manipulated objects to progress toward a desired task outcome. Generative policies can produce plausible robot motions without ensuring this progress, allowing successive action chunks to stall or undo earlier changes to the scene. We introduce a task-centric inference-time refinement framework for flow matching policies that evaluates candidate action chunks through parallel physics-based rollouts and searches for motions satisfying sufficient conditions for task convergence. Task-level performance funnels bound temporary regressions while requiring net progress over each chunk. We establish sufficient conditions under which repeated funnel satisfaction yields convergence throughout execution, and use interval-wise Lipschitz bounds to verify continuous-time funnel satisfaction from sampled rollouts. To accommodate contact-rich hybrid dynamics, we refine the flow's source seeds using derivative-free Covariance Matrix Adaptation Evolution Strategy (CMA-ES), constrained to radial quantile bands of the source distribution to help retain the learned motion prior. This formulation supports both Euclidean and pose-valued Riemannian Flow Matching (RMFM) policies. On PushT and three-cube stacking, refinement raises success from 31.3% to 88.5% and from 77.0% to 86.0%. On PushT, whose coverage score responds continuously to the motion of the block, a learned funnel lowers the average maximum loss of achieved progress by 19% relative to constraining the endpoint of each chunk alone, at a similar success rate. With the radial band, 11.3% of the executed motion windows are out of distribution, a rate within the range of held-out demonstrations, compared with 34.1% for an unconstrained search.
Introduction
Diffusion and flow matching policies learn multimodal distributions over action chunks, enabling complex manipulation behaviors from demonstrations [21, 13] (Rouxel et al. 2024). Yet plausible motions do not by themselves ensure task completion: successive chunks can stall or undo earlier progress. For example, a robot folding a shirt may generate plausible grasping and sweeping motions while repeatedly disturbing an earlier fold. Progress must therefore be assessed through the evolution of the manipulated objects, whose desired arrangement defines completion even when many robot configurations are compatible with it.
Figure 1. Generative policy candidates are evaluated through their predicted task evolution, refined against a performance funnel, and executed before replanning from the new scene.
Existing methods refine generative plans at inference time to satisfy safety and feasibility constraints, using barrier functions or constrained sampling (Xiao et al., 2025; Zhang et al., 2025). Stability-oriented methods also guide generation or constrain learned motion dynamics through conditions that encourage or require a Lyapunov function to decrease at each step (Mizuta and Leung, 2024; Pérez-Dattari et al., 2026). These approaches address collision avoidance, admissible trajectories, and convergence of robot motion. Such requirements do not by themselves ensure that successive action chunks advance the manipulated objects toward task completion.
A recent line of work instead evaluates and refines generated actions through their consequences predicted by learned world models [28] (Qi et al. 2026). Task-oriented objectives include predicted progress or distance to a goal at the end of a chunk or planning horizon [37] (Yan et al. 2026), as well as accumulated rewards and terminal value estimates [34]. These objectives improve predicted outcomes, but do not specify how much intermediate regression is acceptable or provide sufficient conditions for convergence under repeated execution. In particular, a favorable endpoint can conceal substantial loss of progress within the chunk.
What remains unresolved is how to formulate task-progress conditions for successive action chunks of generative manipulation policies that accommodate temporary setbacks while ensuring convergence, and how to use these conditions for inference-time refinement through physics-based simulation. We introduce a framework for flow matching policies that evaluates candidate action chunks through parallel simulated world rollouts and searches for motions satisfying sufficient conditions for task convergence. The pretrained policy supplies candidate motions, while simulation predicts their effects on the manipulated task before execution. This framework is supported by three contributions: task-level performance funnels, verification from sampled rollouts, and constrained optimization of the flow’s source seed.
First, manipulation can require temporary setbacks, such as repositioning fabric before completing a fold (Mao et al., 2026). We introduce task-level performance funnels that bound these setbacks while requiring net progress over each action chunk, and establish sufficient conditions under which repeated funnel satisfaction yields convergence throughout execution. These funnels build on finite-step Lyapunov conditions, which permit intermediate increases while requiring net decrease (Noroozi et al., 2020), and on funnel Model Predictive Control (MPC), which constrains transient error [9], applying both ideas to task error over action chunks.
Second, sampled rollouts can miss funnel violations between prediction times. We use interval-wise Lipschitz bounds (Lera and Sergeyev, 2013) to verify satisfaction throughout continuous execution, and introduce a practical variant based on locally estimated rates of change.
Third, contact-rich hybrid dynamics motivate sampling-based optimization. To exploit parallel candidate evaluation while seeking effective refinement within few sequential iterations, we use the Covariance Matrix Adaptation Evolution Strategy (CMA-ES) [35]. We constrain the search to a radial band of the source distribution’s typical set to help retain the learned motion prior, extending earlier approaches based on noise standardization and typical-radius projection [37] (Stölzle et al. 2026).
In summary, our contributions are
Inference-time refinement for task convergence. A framework for flow matching policies that evaluates candidate action chunks through parallel physics-simulated world rollouts and searches for motions satisfying sufficient conditions for task convergence.
Task-level performance funnels. Bounds on task error that allow temporary setbacks while requiring net progress over each action chunk, with sufficient conditions for task convergence throughout execution.
Verification from sampled rollouts. A procedure for checking continuous-time task-funnel satisfaction using interval-wise Lipschitz bounds, with a practical variant based on locally estimated residual rates.
Seed refinement with radial quantile bands. An extension of prior seed-refinement methods [37] (Stölzle et al. 2026) that replaces fixed-radius normalization with radial quantile bands and applies CMA-ES in the Gaussian source coordinates of both Euclidean and pose-valued Riemannian Flow Matching (RMFM) policies.
An extended discussion of related work is provided in Appendix § 8.
Overview

Figure 2. Whole-horizon task residual, Flow prior, Tracking controller, World dynamics.
Our aim is to turn the motions proposed by a learned policy into sustained progress toward task completion. At each planning step , the policy observes the scene and proposes a finite-horizon motion, which is refined against its predicted effect on the task and executed before a new observation starts the next step (Figure 1).
Task Progress. A task-error measure quantifies how far the scene is from the desired outcome. We prescribe an envelope for this error over the duration of a motion and evaluate whether the predicted task evolution stays within it. The envelope allows useful temporary regressions while requiring a net improvement by the end. Repeating this requirement connects individual motion choices to task convergence. Refining a policy proposal. Conditioned on the observation history , the learned flow map transports a random seed into a waypoint action chunk . Refinement searches over the seed while leaving this map fixed. A low-level controller tracks the chunk’s waypoints and produces the applied input , e.g. motor torques. In (1), is the world trajectory from the current state , extracts its task state, measures task error, and is the envelope over the horizon . The objective measures the largest departure from the desired task evolution over the entire horizon, and a plan with nonpositive worst-case residual satisfies the funnel throughout its rollout. The search ranks plans by a smooth maximum of the sampled residuals, which accounts for the worst residual together with the values close to it (§ 4).
Task-Centric Refinement
World dynamics, task state, and task potential. Let denote the state of the robot and its environment, the applied input, and a waypoint action chunk, which the controller tracks according to its execution timing. Under the controlled dynamics of (1), at iteration the plan induces a rollout from the current world state over , including tracking and contact dynamics (Appendix § 13.§ 2 states the regularity assumptions).
We formalize task completion through the manipulated objects rather than a desired robot configuration. In stacking, for instance, the relative cube placement describes the target, while the arm can take many configurations compatible with it. We introduce a task state and a goal set .1 The task rollout is . Progress is measured by a task-level Lyapunov candidate , which we call the task potential, with goal set , . An exact goal has , with positive outside , and a positive threshold describes completion within tolerance. The potential encodes the goal and a useful ordering of intermediate task states, but it need not decrease under any prescribed controller.
Performance funnels and task convergence. Although decreasing expresses progress toward the goal, requiring it to decrease at every instant would exclude useful preparatory motions. We therefore describe acceptable task evolution through a nonnegative envelope . Starting from the current value , this envelope allows temporary increases while requiring a smaller terminal value, so that those maneuvers produce net progress:
with and . We ask the candidate motion to remain within this envelope throughout execution:
The terminal condition controls progress at replanning times, while the transient bound limits how far the task may regress between those decisions. Any envelope that satisfies (2) can be used, fixed or chosen anew at each iteration.
Theorem 1 (Task convergence throughout execution) Suppose each selected chunk satisfies its funnel (3) with an envelope obeying (2), is executed over the full horizon before replanning, and has an evaluated task rollout that matches execution. If the terminal contraction is uniformly positive, , and the relative transient allowance is uniformly bounded, , then
Task error therefore converges to zero throughout execution. For , execution enters after finitely many chunks and remains there while these conditions hold.
The terminal contraction reduces the task error at replanning times, and the transient bound controls the error between them. Appendix § 13.§ 1 gives the proof and the product form for iteration-dependent rates. It also extends the result to intermittent progress, history-dependent funnel parameters, a fading start allowance and bounded endpoint errors.
Continuous-time verification from samples. Checking (3) directly requires the task state at every instant of the rollout, while numerical simulation supplies it only at finitely many instants. We therefore write the requirement through the residual and its worst value over the horizon,
so that the funnel holds over the whole horizon exactly when . Simulating gives the residual at instants , with spacings , samples , and largest sampled value . Requiring , which we call sampled verification, checks the funnel at the samples. Verification over the whole horizon additionally accounts for the residual between consecutive samples, which the following result bounds through the regularity of the residual in physical time.
Theorem 2 (Continuous-time verification from samples) Fix an iteration and a plan , and suppose that is -Lipschitz on each interval . Then,
Consequently,
On each interval, the residual lies below the two lines of slope through its samples, and these lines meet at the value in (6) (proof in Appendix § 13.§ 3). Appendix § 13.§ 2 bounds the rates through the task geometry and a bounded configuration speed. In the experiments we estimate each interval’s rate from the trace being judged, as the largest secant slope of the residual among the nearby intervals. Substituting these local rates into (6) gives estimated verification, the procedure we use and report (Appendix § 13.§ 5). The guarantee of (7) holds whenever the rates upper-bound the true residual rates, and estimated verification applies the same bound with sample-derived rates.
Generation and Refinement
Flow-matching prior. Given demonstrations of observation histories and action chunks, a conditional flow-matching policy learns a vector field (Lipman et al., 2023, 2024). Integrating from a source seed, , to decodes the seed into an action chunk . Generative time parameterizes the construction of the entire chunk, and physical time describes the execution of the resulting motion. The framework supports Euclidean actions, trained with the Optimal Transport (OT) path, and pose-valued actions, trained with RMFM [20, 15] from a data-centered wrapped-normal rotational source (Appendix § 9). With the policy, the observation and the sampler fixed, decoding is a deterministic map from seed to chunk, and refinement searches over its input.
Search objective. The search ranks candidate plans by a smooth maximum of their sampled residuals, the unnormalized log-sum-exp
It accounts for the worst residual and for the values close to it, and the temperature controls how closely it approximates the largest sampled residual [14 §3.1.5]. This smoothing acts across the samples of one rollout and serves the ranking of candidates. The funnel verdict of a plan comes from estimated verification, which uses the regularity of the residual in physical time (§ 3; Appendix § 13.§ 5). Each planning call starts from the nominal proposal of the policy, keeps the lowest- plan among all evaluated candidates (Algorithm 1), and executes it together with its verification status. The results of § 3 apply to the executed chunks that satisfy their funnel. Appendix § 12.§ 1 gives the stopping rules.
Radial quantile band. Seeds drawn from a high-dimensional standard Gaussian concentrate on a thin shell around a typical radius, and the flow is trained to transport seeds from this shell. Prior work fixes the radius of the seed to its typical value [37] (Stölzle et al. 2026). We extend this projection to a radial band, so that the radius of the seed varies within a prescribed quantile interval of the shell. For standard Gaussian seed coordinates , the projection onto the centered band is
which shifts the entries to zero mean and clips the radius. The radii and are the quantiles of the source radius at tail probabilities and , with the standard normal distribution function (Appendix § 12.§ 1). A typical seed therefore keeps its radius and is centered. The band encourages the search to stay where the flow was trained, so that the seeds decode into chunks that resemble the demonstrated motions, as § 5 measures.
Band-constrained CMA-ES. Contact-rich rollouts are evaluated in parallel, which suits a population search. CMA-ES [1, 35] samples , , and ranks the samples by . The seed chart maps the coordinates to a seed of the source. It is the identity for a Euclidean flow and the exponential chart of the wrapped-normal source for a pose-valued flow, in which the source is exactly (Appendix § 12.§ 1). As in the standardized Separable CMA-ES (Sep-CMA-ES) of Stölzle et al. (2026), every sampled seed is projected, and we additionally project the mean, , after each update.

Figure 1.
Experiments
We compare nominal execution, the flow-matching policy without refinement, with refined execution on planar PushT and three-cube stacking in robosuite ((Zhu et al., 2020; Todorov et al., 2012)), with stacking demonstrations from MimicGen StackThree_D1 ((Mandlekar et al., 2023)). Appendix § 12.§ 4 gives the environment and execution details, and Appendix § 14 reports further ablations and two-nut assembly.
Task progress and evaluation. Refinement is guided by the task potential , where lower is better: a weighted pose error on the single-stage PushT (Appendix § 10.§ 4) and a phased potential on stacking, which also orders the intermediate task states (Appendix § 10.§ 5). We measure the physical outcome with each environment’s own task score , where higher is better, and its success predicate. On PushT, is the coverage of the goal by the block, with success at . Coverage changes continuously with the motion of the block, so the score registers progress within a chunk. On stacking, , where is the footprint overlap of cube X on cube Y times their contact, and success requires the tower to stand after the gripper releases it and retreats. The score also measures partial progress in episodes that do not succeed.
Policies. On PushT we follow Diffusion Policy ([21]) and use its one-dimensional U-Net conditioned by Feature-Wise Linear Modulation (FiLM), trained with the Euclidean OT path. On stacking we use a transformer based on the Diffusion Transformer (DiT) architecture ((Peebles and Xie, 2023)) trained with RMFM ([20, 15]) along screw-motion paths on End Effector (EE) poses (Appendix § 9). Architectures and training settings are in Appendix § 12.§ 3.
Refinement objectives. All refined runs use the same framework, with the same potential, rollouts and search, and differ in the objective (Appendix § 11). Three objectives correspond to those of prior work. Endpoint-only keeps the terminal contraction of the funnel and constrains at the end of the chunk, as progress- and goal-based objectives do [37] (Yan et al. 2026). asks to decrease throughout the chunk, as stepwise Lyapunov conditions do (Mizuta and Leung, 2024; Pérez-Dattari et al., 2026). sums over the chunk, as a model-predictive cost does [34]. The plateau funnel bounds the interior uniformly by , and the linear funnel prescribes steady progress. The remaining funnels are fitted to demonstrated traces of and share one shape, which descends to and adds an allowance that vanishes by the end of the chunk (Appendix § 11). Calibrated funnels use constant parameters fitted over the whole task (global). Learned funnels predict the parameters from the observation with a small network, with allowances in units of (additive) or as fractions of (multiplicative). Fitting uses demonstrations only, never refined rollouts, so a fitted funnel describes the regressions and progress of demonstrated behavior. A funnel is more lenient when it requests less terminal progress or allows to rise further within the chunk. The leniency of a learned funnel is a quantile level: given the observation, a fraction of the demonstrated chunks reaches the requested progress and a fraction stays within the allowance, so a larger gives a more lenient funnel (Appendix § 11.§ 2).
Protocol and metrics. An episode runs until the success predicate holds or its step budget is spent, and every chunk is executed in full. All configurations share 400 initial conditions and are paired: in each episode they use the same initial state, random seeds and initial source draw, from which refinement starts. The policy is trained on all demonstrations, and the fitted funnels on a separate split (Appendix § 11.§ 2). We report success and the of the final score, the mean over the 10% of episodes with the lowest score (Rockafellar and Uryasev, 2000). Progress retention is measured by the maximum drawdown , the largest fall of the score below its running maximum, in points (), through its mean and its , the mean over the 10% of episodes with the largest drawdown. For funnels with an interior bound, we report the share of executed chunks that pass estimated verification. A difference is significant when its paired-bootstrap 95% interval excludes zero (Appendix § 14.§ 1).
Results. Refinement raises success above nominal execution with every objective, and the terminal contraction of the funnel already gives most of the gain. Endpoint-only refinement raises success from 31.3% to 86.8% on PushT and from 77.0% to 86.0% on stacking, and funnels that also bound the interior reach the same level, with the highest PushT success, 88.5%, for the calibrated global funnel (Table 1; all configurations in Appendix § 14.§ 3).

| Objective | Success | Final score | Max drawdown [pts] ↓ | Verified | ||||
| PushT [%] ↑ | Stack. [%] ↑ | PushT CVaR ↑ | Stack. CVaR ↑ | PushT Mean | Stack Mean | PushT CVaR | Stack CVaR | |
| Nominal | 31.3 | 77.0 | .000 | .000 | 40.0 | 8.5 | 86.9 | 46.1 |
| Endpoint-only | 86.8 | 86.0 | .560 | .084 | 28.3 | 6.8 | 62.8 | 46.1 |
| 60.5 | 85.5 | .218 | .103 | 23.4 | 5.8 | 54.2 | 41.8 | |
| 80.0 | 82.0 | .499 | .000 | 22.6 | 6.4 | 54.4 | 43.4 | |
| Plateau | 73.0 | 83.8 | .494 | .075 | 23.9 | 6.9 | 56.7 | 46.2 |
| Linear | 54.5 | 78.8 | .194 | .000 | 24.3 | 7.6 | 54.7 | 44.3 |
| Calibrated global | 88.5 | 80.5 | .587 | .001 | 27.4 | 7.5 | 62.9 | 46.2 |
| Learn. add. | 84.8 | 85.0 | .613 | .162 | 22.9 | 7.6 | 52.3 | 47.0 |
| Learn. mult. | 63.8 | 84.0 | .424 | .107 | 23.5 | 5.7 | 54.0 | 40.5 |
Table 1. Funnel ablation, selected configurations; best refined configuration in bold. Verified: share of complete executed chunks that pass estimated verification. Verified applies to funnels with an interior bound. Right: PushT drawdown exceedance; lower curves mean fewer episodes with large losses of achieved progress.
The interior bound works well when it admits the regressions that the task needs. On PushT, a useful motion often moves the T away from its target to set up a better push, so rises within the chunk. Funnels with a transient allowance accommodate this rise, and the objectives that ask to fall throughout the chunk, and the linear funnel, reach 54.5% to 60.5% success. On stacking, decreases along successful executions, and the refined configurations reach 80.5% to 86.0% success, except the linear funnel, which requests steady progress throughout the chunk and reaches 78.8%.
Where the score registers progress within a chunk, the interior bound retains more of it. On PushT, every learned funnel significantly lowers the drawdown relative to endpoint-only and places the whole drawdown tail below that of nominal execution (Table 1, right; Appendix § 14.§ 5). The learned additive funnel at retains the most, lowering the drawdown CVaR from 62.8 to 52.3 at a success statistically on par with endpoint-only. On stacking, the learned multiplicative funnel at significantly lowers the drawdown CVaR, from 46.1 to 40.5, at on-par success. Figure 3 shows representative refined and nominal episodes on both tasks.
Figure 3. Representative refined and nominal episodes on PushT (left, with , its funnels and a framed planning call) and stacking (right, same initial condition).
Leniency trades requested progress for verification: more lenient funnels pass estimated verification on more of their executed chunks and succeed in fewer episodes (Appendix § 14.§ 3). Appendix § 14.§ 6 examines the choice of the potential.
Search method comparison. On PushT, we compare our search with other searches on 200 new initial conditions, with the same U-Net policy and the plateau funnel at as the shared objective. Ours is CMA-ES on the band of (9) at , the setting of every other experiment. CMA-ES without the band isolates the role of the band. Best-of- decodes a single batch of 200 seeds, and Cross-Entropy Method (CEM) (Rubinstein and Kroese, 2004) is a second adaptive population search, both on the same band. Limited-Memory Broyden–Fletcher–Goldfarb–Shanno (L-BFGS) (Nocedal and Wright, 2006) descends the same objective through the flow and a smoothed differentiable reimplementation of the PushT dynamics, and the population searches evaluate the objective on rollouts of the native simulator (Appendix § 12.§ 2). Each iterative search runs for 1.5 s per chunk. We measure smoothness by the Log Dimensionless Jerk (LDJ) ([6]) within chunks, and similarity to the demonstrations by the share of executed windows that are Out of Distribution (OOD) with respect to the training demonstrations under a nearest-neighbor test ((Sun et al., 2022)).
Band-constrained CMA-ES reaches 86.5% success, compared with 70.0% for L-BFGS, 82.5% for best-of- and 79.0% for CEM (Table 2). Its success is significantly higher than that of L-BFGS, and its lower-tail final score is significantly higher than those of L-BFGS and best-of-. The success differences from best-of- and CEM have confidence intervals that contain zero. Removing the band raises success to 96.0%, increases the share of out-of-distribution windows from 11.3% to 34.1%, and lowers smoothness from an LDJ of −9.93 to −10.96. With the band, the OOD rate lies within the range of held-out demonstrations (9.6%, 95% interval 5.4–15.4%), and Table 2 marks the rates above this range. The band thus trades some success for motion that stays close to the demonstrations. Appendix § 14.8 reports the complete comparison, including Adam, Model Predictive Path Integral (MPPI), the fixed-radius sphere and a sweep of the band width.
| Search | Succ.↑ | CVaR ↑ | LDJ↑ | OOD%↓ |
| L-BFGS† | 70.0 | .765 | −10.15 | 12.0 |
| Best-of- | 82.5 | .768 | −9.87 | 4.9 |
| CEM | 79.0 | .848 | −10.28 | 8.0 |
| CMA-ES, no band | 96.0 | .941 | −10.96 | 34.1 |
| Ours, | 86.5 | .877 | −9.93 | 11.3 |
Table 2. Search methods on PushT. Better/Worse than ours (significant). Significance refers to paired differences from our search. †Gradient.
Conclusion, Limitations, and Future Work
We presented a task-centric inference-time refinement framework for flow matching policies, which evaluates candidate action chunks through parallel physics-based rollouts and searches the flow’s source seeds for motions that satisfy sufficient conditions for task convergence. These conditions take the form of task-level performance funnels, which accommodate the temporary regressions that manipulation often requires while asking for net progress over each chunk, so that their repeated satisfaction drives task error down throughout execution and can be verified from sampled rollouts through interval-wise Lipschitz bounds. On PushT and three-cube stacking, refinement raises success far above nominal execution, as the funnel’s terminal contraction steers each chunk toward net progress, and its transient bound helps retain the progress already achieved on PushT, where the task score registers it. Radial quantile bands on the source keep the refined motion close to the demonstrations.
Limitations and future work. The quality of refinement follows the quality of the task potential , which we design by hand from privileged world state. Learned progress measures are a natural route to perceptual and long-horizon tasks. Refinement also uses the simulator as its world model, so it requires the state of the scene and a simulator whose rollouts predict the executed motion. Learned world models could take this role on physical systems. The convergence results apply to executed chunks that satisfy their funnel, the search can execute a plan that does not, and estimated verification uses rates derived from the samples in place of certified bounds. Finally, planning takes seconds per chunk (Appendix H), during which the scene has to stay still, so refinement does not yet run in real time. Appendix § 16 discusses these points further.
Acknowledgments
This work was supported in part by the European Union’s Horizon Europe Programs from Project EMERGE (Grant No. 101070918), the Singapore MIT Alliance on Research and Technology (SMART) under the Mens, Manus, et Machina (M3S) program.
Use of AI. The authors used AI assistants to help write and debug the code, to draft and revise the text, to check the proofs, and to search for related literature. All ideas, methods, and scientific contributions are the authors’ own. The authors reviewed and verified everything the assistants produced and take full responsibility for the content of this paper.
Related Work
Generative policies for robotics. Generative policies learn expressive models of multimodal robot behavior from demonstrations, representing multiple valid ways to perform a task [21] (Rouxel et al. 2024). Diffusion and flow matching support conditioning on robot state, images, point clouds, and language instructions [21, 23, 13], allowing motion generation to respond to both the scene and the requested task. These policies commonly generate action chunks: sequences of future commands whose initial segment is executed before replanning from updated observations in a receding-horizon loop [21, 13]. Actions often specify desired joint configurations or end-effector poses over time, so a chunk describes a robot motion sequence tracked by a lower-level controller [21, 13]. Manifold-aware formulations additionally account for the geometry of pose-valued actions [15, 27]. We use a pretrained flow matching policy as a fixed prior over waypoint chunks.
Inference-time refinement of generative policies. Inference-time refinement can act on generated motions, intermediate sampling states, or source noise. Direct motion refinement uses generated action sequences to initialize trajectory optimization [34] (Qi et al. 2026), but subsequent updates can drift from the learned prior. Gradient guidance steers diffusion or flow updates using differentiable objectives [17, 32]. Projection methods enforce constraints on intermediate samples or their estimated clean outputs [24] (Yuan et al. 2023; Watanabe et al. 2026), requiring feasibility evaluation before generation is complete. Source-noise optimization evaluates objectives on fully generated motions: gradient-based updates differentiate through both the generator and the objective [8, 39], while sampling-based updates use only objective evaluations [37] (Stölzle et al. 2026). We use sampling-based source optimization with radial quantile bands to restrict the search to typical source-noise radii.
World models for task progress evaluation. World models support action selection and refinement by predicting the task outcomes used to evaluate candidate actions [29] (Suh and Tedrake 2021). Distances between predicted and goal representations guide planning in learned visual spaces [4, 37] (Zhou et al. 2025). Generative policy proposals can also be ranked or refined using predicted rewards and task objectives [28, 34] (Qi et al. 2026), or guided by learned progress estimates (Yan et al., 2026). We use physics-based world rollouts to evaluate task evolution under tracking and contact dynamics.
Task progress measures. Quantifying this progress is difficult when tasks involve intermediate milestones, regressions, and recovery. Beyond geometric task potentials, visual and language-conditioned representations provide learned goal proximity and reward signals (Ma et al., 2023b,a). Reward models learn completion and partial-success assessments from robot videos, incorporating failures and trajectory comparisons [41] (Liang et al. 2026). Finer assessments model task stages and progress within them [18 b], or process-level advancement, regression, and recovery (Mao et al., 2026; Tan et al., 2026; Xu et al., 2026). Reward machines encode sequential milestones explicitly [16, 5]. We express task progress through a scalar measure of deviation from desired object relationships, combining subtask measures to account for sequential goals.
Safety and convergence of robot motion. One line of work incorporates Lyapunov or contraction conditions into training objectives or model architectures to obtain stable robot motion dynamics [7] (Pérez-Dattari and Kober 2023; Pérez-Dattari et al. 2026). Another establishes closed-loop stability through online predictive optimization, using predictive control to select inputs or predictive filters to correct proposals from an existing policy [26] (Mayne et al. 2000). Stability conditions also differ in how they treat transients. Finite-step Lyapunov conditions allow intermediate increases by requiring net decrease over several steps (Noroozi et al., 2020). To also regulate the transient error, prescribed-performance and funnel control specify admissible envelopes [38, 10], which can be incorporated into predictive control [33, 9]. We apply these principles to progress of the manipulated objects, combining bounded transient regression with terminal contraction of a task potential over generated action chunks. Convergence remains conditional on finding satisfying chunks and agreement between evaluated and executed dynamics. Recursive feasibility is not established.
Continuous-time verification from sampled rollouts. Extending discrete trajectory checks to continuous-time satisfaction requires regularity assumptions and margins [31]. Lipschitz optimization bounds function values between samples and uses local rate estimates to reduce conservatism (Lera and Sergeyev, 2013). Our verification procedure uses bounds on how quickly the task-funnel residual can change to rule out violations between consecutive rollout samples. With valid upper bounds on this rate of change, passing the check guarantees that the task error stays within the prescribed envelope throughout the chunk. In our experiments, we estimate these rates from the sampled rollouts, and call the resulting check estimated verification.
Flow-Matching Priors and Pose-Valued Waypoints
Conditional flow-matching training. The flow map of the learned vector field transports a source distribution to the conditional data distribution, , where the pushforward denotes the distribution of for (Lipman et al., 2023, 2024). For Euclidean actions, regresses the velocity of the path , with loss over , and . For pose-valued actions we use RMFM [20, 15] with the data-centered wrapped-normal rotational source described below. In both cases a seed is decoded into an action chunk by integrating from to .
Pose notation. We use standard Lie-group notation for and : exponential and logarithm maps, and the hat and vee operators identifying a body twist with its Lie-algebra matrix (Solà et al., 2021; Lynch and Park, 2017).
Interface, carrier, and velocity representations. The world-facing waypoint representation is eight values: position, a unit quaternion, and a gripper variable. The Euclidean (OT) policy flows these eight coordinates directly and predicts eight coordinate velocities. Before execution, its quaternion block is normalized and converted to a rotation. Quaternions, however, are a discontinuous representation of rotations for a regression target (Zhou et al., 2019), so the Riemannian (RMFM) policy flows a continuous carrier instead: the nine rotation-matrix entries, three translation coordinates, and the gripper channel. This 13-dimensional carrier represents a state in , and the group operations act on it directly as matrix products, which keeps the pose kernels of the flow simple. The model reads the 13 carrier channels and outputs seven tangent channels, a body twist and a gripper rate. Quaternions appear only in the world-facing interface. The RMFM flow evolves the 13-dimensional carrier, and the refinement search operates on chart coordinates of its source (Appendix § 12.§ 1). Rotation observations use the distinct six-dimensional representation of Zhou et al. (2019).
Coupled pose interpolation and integration. Write for the pose and for the gripper variable. For source and target poses, let . The training path is
a screw motion with constant body velocity , which couples translation and rotation through the exponential, while the gripper moves at constant rate . Applied waypoint-wise, this gives the flow-matching target ([15, 20]). Sampling uses 10 Lie–Euler steps,
so the rotation stays on without re-orthonormalization. The final carrier is converted back to the eight-value interface for execution.
Data-centered rotational source. The source samples translation and gripper coordinates from standard Gaussians in normalized units, and rotation from a wrapped normal centered on the data,
which is then converted to the 13-dimensional carrier. Here is the skew-symmetric matrix representation. The center is computed from demonstration rotations: its unit quaternion is a dominant eigenvector of , the sign-invariant chordal quaternion average (Markley et al. (2007)), computed by power iteration. The prior center is saved with the training statistics. Centering the source on the demonstrated orientations reduces the frequency of source–target pairs near the cut locus of the rotational logarithm, where a relative angle near makes the interpolation target bimodal. For concentrated demonstrated orientations, almost all pairs lie well inside the cut locus. A Haar-uniform source (Chirikjian [22]) places a fixed fraction of pairs near the cut locus for any data.
Training and inference use the same Gaussian-to-pose source map. The source samples translation and rotation as separate factors, and the flow couples them through the learned pose velocity and its integration with the exponential. The map is injective for rotation angles below , where the principal logarithm recovers (Hartley et al. [36]).
Task Progress Measures and Task Potentials
This appendix constructs the task potential of § 3, a task-level Lyapunov candidate, so that does not increase while the task progresses as intended: the subtasks are completed in order, each by first meeting a prerequisite, such as lifting a cube, and then completing it, such as placing the cube on its support. Executed motions can leave this progression, through robot-only motions that leave constant, contacts that push, drop or topple objects, and detours away from the goal, so remains a candidate, and the funnel imposes its decrease on each executed chunk. All constructions are stated on a bounded operating domain of task states, set by the task definition and the training data: the physical limits of the scene, such as the table extent, together with the range of task states covered by the demonstrations, with a margin.
This appendix has two parts. The first is a construction procedure that can be reused for other tasks with identifiable subtasks: the requirements that a potential should meet, a way to blend the costs of one subtask into a smooth residual without ridges (Appendix § 10.§ 1), and a way to compose the residuals of successive subtasks so that completing one never increases the potential (Appendix § 10.§ 2, Proposition 3). The second part consists of the potentials of our three tasks (Appendices § 10.§ 4–§ 10.§ 6). Their coordinates, costs, gates and constants are designed by hand for each task. They are instances of the procedure and make no claim of generality.
Requirements. The method places four requirements on the potential over .
Zero set. is nonnegative and vanishes exactly on the completed task, so that the terminal contraction of Theorem 1 drives execution toward completion.
Regularity. is Lipschitz along rollouts, as the verification bound requires (Lemma 5). We construct it , which gives a Lipschitz constant on the bounded domain and keeps kinks out of the trace that the funnel evaluates.
No ridges. A motion that advances the current subtask never increases , so the funnel does not penalize progress on that subtask.
Ordering. Completing a subtask never increases , and does not depend on a later subtask until the earlier ones approach completion.
For a single-stage task, a weighted distance to the desired state meets these requirements, as in PushT (Appendix § 10.§ 4). For tasks with identifiable subtasks and prerequisites, we give a construction procedure. A subtask residual is a nonnegative scalar function of the task state that vanishes exactly when its subtask is complete. The procedure blends the costs of a subtask into a smooth residual (Appendix § 10.§ 1) and composes the residuals of successive subtasks, so that activating the next subtask preserves the desired ordering of task states (Appendix § 10.§ 2). In stacking, for example, the first subtask places the red cube on the green one and the second places the blue cube on the red one. The prerequisite of each placement is lifting the cube from the table, and its completion is the cube centred and resting on its support. Each task supplies its own geometric subtask costs and completion gates, with a few constants calibrated on demonstrations. We apply the full procedure to stacking (Appendix § 10.§ 5) and to two-nut assembly (Appendix § 10.§ 6). Learning the potential from demonstrated progress, in place of the hand-designed instances, is left to future work.
Designing a Smooth Subtask Residual
Choosing coordinates and regimes. Select coordinates that describe the prerequisite and completion of a subtask, and define nonnegative costs and for these two regimes. A prerequisite can represent clearance before transport or alignment before insertion, and completion specifies the desired task relation. From these two costs we build the subtask residual defined above. It should vanish at the intended geometric goal and decrease along the intermediate motions that lead to it. In stacking, collects the horizontal distance and the vertical gap between a cube and its support, is smallest when the cube is carried at a clearance above its support, and when it is centred over the support and lowered onto it (Appendix § 10.§ 5).
Connecting regimes smoothly. With an offset , let , and blend the two regimes through a gate ,
The gate should equal 0 before the prerequisite is started and 1 once it is met, so that each regime is exact away from the transition. It should also be monotone in the prerequisite’s progress, and with zero slope at both ends of the transition, so that the blend has no kinks. The blend is then nonnegative, and if and vanishes exactly at the goal, where , has the desired zero set. When a scalar coordinate increases with prerequisite progress, the clamped cubic step is the lowest-degree polynomial with these properties,
where is the band over which the emphasis moves from one regime to the other.
Avoiding ridges at activation. A smooth gate avoids discontinuities in the measurement, but it can still create a cost ridge: while the gate rises, the residual can increase while the robot performs the prerequisite motion. A motion that improves the prerequisite should not increase . For a coordinate that increases with the desired prerequisite motion,
Suppose that both regime costs decrease along this motion, and , and that the gate rises along it, , on the transition band where . The first two terms are then nonpositive, and the last one is nonpositive whenever . A sufficient offset is therefore
which gives on the band, the no-ridge requirement. The offset is computed once from and involves no tuning on trajectories.
Composing Subtasks
For two successive subtasks with residuals and , choose a completion gate with and , which exposes the second residual as the first subtask is completed. Choose a reserve and define
While the first subtask is incomplete, and the second subtask enters only through the constant , so does not depend on : in stacking, moving the blue cube before the red one is placed leaves unchanged, so decreases only through the current subtask. As the first subtask is completed, is exchanged for the actual second residual, which is no larger on , so the exchange cannot itself increase .
The gate reads a gate residual : a nonnegative residual of the first subtask that vanishes on the same set as . The simplest choice is . A separate gate residual is useful when contains terms that keep refining an already completed subtask, such as fine centring: the gate can then hand over to the next subtask as soon as the first is complete, without waiting for that refinement. One suitable completion gate is
with for and for : is the band of first-stage gate residual over which the second subtask is activated.
Proposition 3 (Smooth sequential composition) Let , , and be nonnegative residuals with , and let and be as above. Then is nonnegative and on , with exactly when . In residual coordinates,
Proof. Every term in (17) is nonnegative. If , then , hence , , and ; the converse follows by substitution. Products and compositions preserve regularity. Differentiation gives (19), whose signs follow from and . ■
Reducing either first-stage residual at a fixed second residual therefore never increases , including during activation, and the first subtask has full weight while the second has weight . Together with the zero set and the regularity of the proposition, this meets the ordering requirement. Along a trajectory, all residuals change together,
so the construction does not fix the sign of , and the funnel evaluates how evolves there. Longer sequences follow by applying the composition recursively.
Parameter Selection and Calibration
The constants of a potential come from three sources, and each task uses only the groups its potential needs. Table 3 and Table 4 list every constant of the stacking and two-nut potentials with its source. The PushT pose error has a single angular weight and no stage constants, and its weight equates an angular and a positional tolerance (Appendix § 10.§ 4).
| Symbol | Meaning | R on G | B on R | Rule |
| Geometry and physical tolerances | ||||
| half-heights | 0.020/0.025 | 0.020/0.020 | model geometry | |
| error scales | 0.025 | 0.020 | ||
| vertical weight | 1 | 1 | design | |
| lowering band | 0.010/0.045 | 0.010/0.040 | design; | |
| carry clearance | 0.050 | 0.050 | ||
| lift band | mm above support, 15 mm band | |||
| pre-positioning | 0.01 | 0.01 | design | |
| alignment | 10 | 10 | above jitter, below a stage drop | |
| bands | gate residual | , | wider, no alignment basin | |
| Analytic composition constants (on ) | ||||
| lift offset | 559.65 | 868.83 | (24) | |
| gate-residual offset | 549.65 | (24), | ||
| second-stage reserve | 1139.36 | |||
| no-ridge margin | 0.0045 | lowering-band condition | ||
| Demonstration-informed | ||||
| operating domain | at reset; | MimicGen reset range + margin | ||
| alignment scale | 0.010 | 0.010 | typical demo seat offset | |
| completion-gate band | 1.093/2.186 | largest completed; |
Table 3. Phased potential parameters for three-cube stacking, grouped by source, for red on green (R on G) and blue on red (B on R). Lengths are in meters; costs and weights are dimensionless.
| Symbol | Meaning | Square | Round | Rule |
| lateral tolerance | 0.03 | 0.03 | half-width of the native success box | |
| seated / approach height | 0.83/0.97 | 0.83/0.97 | model geometry; peg top plus nut thickness | |
| aligned threshold | 0.101 | 0.163 | (seated offset/) | |
| tilt weight | 5.13 | 3.11 | of the threading tilt limit | |
| yaw weight | 0.0127 | 0 | (clearance/); none for the round nut | |
| valve closure | 1 | 1 | edge of the native box | |
| height reserve | 5.04 | 5.04 | , , | |
| lift credit, corner width | 5.04 | 5.04 | ||
| lift band | 0.02 | 0.02 | ||
| Analytic composition constants (on ) | ||||
| second-stage reserve | 46.9 | |||
| Demonstration-informed | ||||
| lift height | 0.89 | 0.89 | highest spawn height of the reset | |
| alignment bound on | 28.35 | 36.78 | 1.1 largest observed | |
| completion-gate band | 0.136/0.271 | 1.1 largest over flat final seats; |
Table 4. Phased potential parameters for two-nut assembly, grouped by source, for the square and the round nut. Lengths are in meters; costs and weights are dimensionless.
Geometry and physical tolerances. Error coordinates come from the task’s object relations and are scaled by object dimensions or acceptable completion errors. In stacking, for instance, the horizontal and vertical error scales are the half-height of the supporting cube, and the carry clearance is one cube height plus one centimetre. Relative weights then set how the normalized errors are combined. We set these weights by hand and use the demonstrations to check that the tolerances accommodate the contact noise of successful configurations.
Analytic composition constants. Offsets and reserves are computed from bounds on the operating domain . The lift offset is the bound (16) evaluated on . The stage reserve is the largest value of the second-stage residual on , which keeps from rising at the hand-over in (17). The composition properties hold on , and the potential remains defined and finite outside it.
Demonstration-informed thresholds. The remaining hand-over thresholds and scales come from training states. In stacking, the completion band starts ten percent above the largest gate residual among training placements that are geometrically complete, and the alignment scale is close to the typical seat offset of demonstrated placements. Placements outside the intended completion geometry are not used to widen the band. All potential parameters are fixed before the funnel’s training labels are generated.
PushT
For block position , target position , and orientations , , use
where , positions are in the pixel units of the workspace, angles are in radians, and , so that an angular error of rad weighs as much as a position error of 10 pixels. For , the potential is nonnegative and vanishes exactly at the target pose. The squared wrapped-angle term is locally Lipschitz, including at the angular cut, though not differentiable there.
Three-Cube Stacking
We apply the procedure to three-cube stacking, which places the red cube on the green cube and then the blue cube on the red one. Each placement is a subtask with a lift prerequisite, and the two placements are composed in this order. Let and be cube ’s center and half-height. The task map extracts . For each placement of on ,
where is the horizontal distance between the two centers and the vertical gap between the bottom face of and the top face of , assuming upright faces.
Placement residual. Dropping the placement subscripts, the lift gate measures how far the cube has been raised relative to its support, and measures horizontal alignment. The vertical target equals the carry clearance far from alignment and approaches zero near it, a curved valley that rewards carrying before lowering. With error scales , a vertical weight , and a small pre-positioning ,
Here is the horizontal misalignment in units of the error scale. The lift cost penalizes the deviation of the gap from the carry clearance , and its small horizontal term moves the cube toward its support while it is lifted. The placement cost penalizes the horizontal misalignment and the deviation of the gap from the valley , so that the cube is lowered as it aligns. The error scales make both costs dimensionless, and weighs vertical against horizontal error. Once the cube is lifted, an alignment basin ranks completed placements by centring, and the residual is
In the transition band, and give , so the rule in (16) is met by
The gate residual has the same form without the alignment basin and with wider bands, so that the hand-over to the second placement does not wait for fine centering.
Potential. With the two placement residuals,
which by Proposition 3 is on and vanishes exactly at the geometric stack : each residual vanishes only where , , and , that is, at . The potential is invariant to common translations and measures geometric placement, not orientation, release, or stable support. Completion is judged by the task’s success predicate. The main experiments use this potential, which builds both placements from the residual of (23). Appendix § 14.§ 6 compares it with a potential that builds both placements from the gate residual . Table 3 lists the constants, grouped by their source as in Appendix § 10.§ 3.
Two-Nut Assembly
The task threads the square nut onto its peg, then the round nut onto the other (Appendix § 14.§ 4). The potential reads the two nuts only, each relative to its own peg. For a nut, let be the horizontal offset of its center from the peg axis, its orientation and its height. The task map extracts for both nuts.
Alignment energy. With the native lateral tolerance and , the lateral error is quadratic inside the native tolerance and linear outside it, for and otherwise, so that it stays and grows slowly far from the peg. Tilt is measured by with , the nut’s axis. The square hole also needs yaw alignment up to its fourfold symmetry, measured with by
which vanishes when an edge of the nut is parallel to an axis of the peg. The round nut has .
Nut residual. An alignment valve , with the clamped cubic step of (14), opens as the nut aligns. The height cost of an aligned nut, , vanishes at the seated height and saturates at the approach height above the peg. A nut counts as resting on the table when it is laterally misaligned and not lifted: with the lift indicator and the lateral valve , its resting indicator is . The residual is
where is a nondecreasing smoothing of with a quadratic corner of width , and bounds the alignment energy on .
Properties. On , aligning a nut at fixed height never raises : for a lifted nut or one over its peg, and , since and , and for a resting nut is nondecreasing. A misaligned nut has height cost at any height and an aligned one has , so lowering an aligned nut to its seat decreases . A nut resting away from its peg () costs wherever it lies: pushing or turning it on the table leaves unchanged, lifting it decreases , and dropping a carried nut increases . Since is the highest spawn height, the reset’s drop of the nuts onto the table does not count as a lift.
Potential. With the square-nut residual as first stage, also used as gate residual, and the round-nut residual as second,
with the completion gate of (18) and , so that by Proposition 3 is on and completing the first placement never increases it. It vanishes only when both nuts are centred on their pegs, level and seated, with the square nut’s yaw a multiple of , a set much smaller than the tolerances of the native success check. Flipped nuts are not excluded. Outside the potential remains and finite, but its bounds are not claimed there. Table 4 lists the constants, grouped by source as in Appendix § 10.§ 3.
Performance Funnels
The funnel is built for a fixed task potential (Appendix § 10) and is frozen at the start of each planning call. The results of § 3 place four requirements on it.
Anchoring. It starts at the current value , possibly raised by a start allowance that fades over the chunk and makes the first samples verifiable (Appendix § 13.§ 2).
Terminal contraction. It ends at the requested value , which drives the convergence of Theorem 1.
Bounded transient. It stays below , which bounds the task error between replanning times.
Lipschitz in time. Its Lipschitz constant enters the rate of the residual, as the verification bound requires (Lemma 5).
Every funnel we compare meets the terminal requirement, and the funnels differ in how much they constrain the interior of the chunk (Figure 4). We compare five types:
Figure 4. Shapes of the compared funnels, relative to the current value (dotted). Endpoint-only bounds only the last sample, the plateau adds a uniform bound , the linear funnel asks for steady progress, and the calibrated and learned funnels follow (30) (two illustrative parameter sets).
Endpoint-only constrains the last sample and leaves the interior free.
Plateau adds a uniform transient bound to the endpoint-only funnel.
Linear decreases at a constant rate from to the requested value over the chunk.
Calibrated funnels use the fitted family of Appendix § 11.§ 1 with constant parameters, calibrated on the demonstrations over the whole task (global) or for each stage of a sequential task (per stage).
Learned funnels, additive or multiplicative, use the same family and predict its parameters from the observation history at leniency (Appendix § 11.§ 2).
We also compare two objectives without an envelope, which the same search minimizes in place of the funnel loss. On the samples of the chunk, judged from the end of the first control step as for the funnels, the objective is the smooth maximum with , where is the kinematic time derivative of on PushT and the difference on stacking. It penalizes any increase of within the chunk. The objective is the running cost , the cost of a model-predictive controller on . Neither defines an envelope, so their searches use a single patience on the improvement of the objective, together with the generation cap and numerical stopping.
Funnel Families
Fixed shapes. With normalized chunk time , the endpoint-only, plateau and linear funnels have fixed parameters,
where is a constant far above any reachable , so that endpoint-only leaves the interior samples free, and with is the clamped cubic step of (14). In the plateau, moves the envelope to its terminal value at the end of the chunk. The plateau rises from to over the first fraction of the chunk, holds it, and falls to over the last, with and . The ramps make the envelope continuous, and therefore Lipschitz, at both ends of the chunk. We set , an arbitrary small value, so that the plateau holds over almost the whole chunk. For a fixed , the plateau and linear funnels, like the multiplicative family below, meet the terminal and transient requirements directly, and both are Lipschitz in time. The endpoint-only funnel jumps from to the terminal value at the last sample, so it has no interior bound to verify.
Additive and multiplicative families. The fitted funnels need a parameterization that meets the four requirements for every value of its parameters, so that fitting cannot break them. Beyond these, the parameters should be few and interpretable, and the transient allowance should have an adjustable size and timing, since demonstrated regressions differ in how large they are and when they occur. The requested descent should also be able to start late in the chunk, after a preparatory motion. We build the family from the simplest functions with these properties, a linear ramp for the descent and cubic steps for the allowances. The learned and calibrated funnels use
with the profiles
where is the clamped cubic step defined above. The descent ramps from 0 at the onset to 1 at , the bump peaks at , and decays from 1 to 0. Here is the requested relative progress, and are the transient and start allowances, is the bump time and the descent onset. In the additive family the allowances are in units of , scaled by the median training value of . The multiplicative family takes them as fractions of the current value,
so that the funnel shrinks with as the task progresses.
How the families meet the requirements. Each requirement follows from the values and slopes of the three profiles, for every admissible parameter value.
Anchoring. At , and , so in the additive family and in the multiplicative one. The funnel starts at raised by the start allowance, which we floor at $0.1V_k
({xref}Appendix F.2`), and fades this allowance over the chunk.
Terminal contraction. At , and , so for any allowances, bump time and onset. The descent carries the requested progress, and both allowance profiles vanish at the endpoint.
Bounded transient. All three profiles take values in , and the descent term only lowers the envelope. The multiplicative family therefore stays below , which gives . The additive family stays below , which gives , a relative bound that grows as decreases (Appendix § 13.§ 5).
Lipschitz in time. The clamped cubic step is with largest slope . The bump rises over and falls over , with zero slope at its peak, so its slope is at most , and has slope at most . The ramp is Lipschitz with slope , including at its onset. With the bump time in and the onset before the last sample, every fitted envelope is therefore Lipschitz in with constant at most
with and multiplied by in the multiplicative family.
The remaining parameters fit the shape to the demonstrations: sets the size of the transient allowance and its timing, and delays the requested descent until after a preparatory motion.
Fitting Funnels to Demonstrations
The learned and calibrated funnels take their parameters from how the task potential evolves along demonstrated chunks. The labels come from demonstrations only, measured with the fixed task potential, and not from refined rollouts or their outcomes. A fitted funnel therefore describes how far the potential rises within a chunk and how much progress it makes along demonstrated behavior, and refinement requires proposed chunks to stay within that envelope. The fitted parameters are fixed before refinement, and every evaluated leniency level is reported in Appendix § 14.§ 3.
Demonstration labels. The policy is trained on the full demonstration dataset. Funnel fitting uses a separate three-way split of the same demonstrations into training, validation and test groups (70/15/15%), made at the level of complete episodes before windows are extracted. Task outcomes are evaluated in simulator episodes from the sampled initial conditions. Each window of horizon starting at boundary gives the initial value , the clipped relative endpoint progress , and the interior trace , . We use the demonstrated prefix up to first success and, for sequential tasks, exclude windows that undo a completed prerequisite according to the task’s completion gates.
Calibrated funnels. Calibrated funnels use the additive family of (30) with constant parameters, fitted directly to the demonstration labels. The training and calibration episodes are disjoint. The bump time and onset are fixed to and , and the progress is the 10% quantile of the progress labels of the training chunks. The two allowances share one scale, . Since the envelope is affine in at fixed , each calibration chunk has a smallest scale for which the envelope contains its samples before the endpoint, the largest ratio between the room it needs above the descent and the room a unit allowance gives. The calibration score of an episode is the largest over its chunks, so an episode is contained at scale when all its included interior samples lie inside the funnel. With calibration episodes, we set to the -th smallest episode score, the finite-sample split-conformal upper quantile at coverage 0.9 ([3]). Under exchangeability of the calibration episodes and a new demonstration episode, the new episode has all its included interior samples inside the funnel with probability at least 0.9. The global funnel fits one parameter set to all chunks, and the per-stage funnel one set to the chunks of each stage of a sequential task, falling back to the global set for a stage with fewer than 10 training or calibration episodes, or when the order statistic above exceeds the number of episodes.
Learned funnels. Learned funnels let the parameters of the family depend on the observation, which tests whether the allowance and the requested progress benefit from adapting to the state. The predictor reads the same observation history as the policy and is trained with the pinball loss , whose minimizer is the -quantile of [40]. At leniency the three heads minimize
Their minimizers satisfy the conditional quantile conditions
These are two separate marginal targets over demonstrated chunks. The first states that the requested endpoint progress is met on a fraction of the chunks, and the second that the interior allowance contains the trace on a fraction of the chunks. A larger lowers the requested progress and widens the allowance, which gives a more permissive funnel. We clip the demonstrated relative progress to , so a chunk that regresses at its endpoint supplies a zero-progress target, and the predicted lies in the same range. The smallest progress a learned funnel requests is therefore zero. The transient allowance is fitted for the current progress prediction, which is held fixed (sg) in within each epoch. The initial sample is covered by the start allowance and is therefore left out of the transient target. The onset labels are the delays before descent in progressing windows. These quantile targets concern demonstrated chunks, the calibrated coverage concerns demonstration episodes, and the verification rates of Appendix § 14.7 count executed chunks, so the three quantities summarize different populations.
The predictor has two hidden layers of 64 Sigmoid Linear Units (SiLUs) and outputs parameter tuples at four leniency levels, . Its parameterization makes nonincreasing and , , nondecreasing in , with a shared and onset no later than the last interior sample, so higher levels give nested, more permissive envelopes. Training uses AdamW (learning rate , weight decay , batch size 512) for up to 200 epochs.
Refinement and Implementation
Typical-Set-Constrained CMA-ES Refinement
Every planning call runs a fresh search, shares the frozen task potential and funnel across all evaluations, and evaluates the nominal policy seed first. Candidate decoding is deterministic for fixed conditioning and numerical integration settings.
Search distribution and band projection. For a flattened seed , CMA-ES samples with , where is the distribution mean, the step size, and the eigendecomposition of the search covariance . Every evaluated seed is , with from (9), and degenerate or non-finite inputs are rejected. The projection first centers the seed, subtracting the mean of its entries so that they average to zero, and then clips the radius of the centered seed to the band. After each CMA-ES update the mean is projected onto the band, . The raw population, covariance, and evolution paths are not modified, so the update itself is standard CMA-ES. All horizon and channel entries form one global group, so is taken over the whole seed, and a seed with zero-mean entries and a radius inside the band is unchanged. Without the band, a CMA-ES initialized at a seed drawn from the source can drift radially away from the origin over the generations, and the decoded chunks then come from seeds the flow was never trained to transport.
For a standard Gaussian, the centered radius satisfies . We place the band endpoints at tail probabilities and using the Wilson–Hilferty approximation (Wilson and Hilferty, 1931). With and ,
The approximation is used for . Fixing both radii to recovers the single-sphere projection of standardized CMA-ES (Stölzle et al., 2026). We use : a source draw then lies outside the band with probability about , so in almost every call the projection centers the nominal seed and keeps its radius. The first evaluated plan is decoded from this centered seed. This differs slightly from the plan of nominal execution, which decodes the uncentered draw. The band constrains the seed’s mean and radius and leaves its direction, channel-wise structure and correlations free.
Euclidean flows. The search runs on the flow’s Gaussian seed, of dimension equal to the chunk length times the width of the action representation (for stacking, ). The initial mean is the projected nominal seed, which decodes to the first evaluated plan.
Riemannian flows. The search runs Euclidean CMA-ES and (9) in chart coordinates of the source at its center. Each waypoint has seven coordinates, a translation , a rotation vector , and a gripper coordinate , so for stacking. They are mapped waypoint-wise to carriers by the source’s own sampling map, the exponential chart at the source center with the per-axis source scales ,
which matches (12). Then is written in the 13-dimensional carrier that the flow evolves. In these coordinates the source is exactly , so the band constrains the Gaussian the flow was trained to transport, with no approximation. The nominal seed is expressed in these coordinates and projected, and, as for Euclidean flows, it is the initial search mean.
Searching in chart coordinates keeps the search distribution Gaussian in the coordinates in which the source is Gaussian, so the typical-set band applies exactly. A Riemannian CMA-ES (Colutto et al., [25]) is an alternative that searches on the carriers themselves, with tangent-space sampling at the current mean, a weighted Fréchet mean update and parallel transport of the adapted covariance.
Algorithm 2: Seed search within one planning call (detailed).
Input: , , frozen , nominal source coordinates
; ; initialize on the band
for do
if ; otherwise ; ,
; , ▷ in parallel
if then ; ▷ projected nominal plan
Rank-update from ;
; if then
if then ; else ▷ threshold of Eq. (38)
if changed then
if (patience, when enabled) or the time budget is spent then stop
if numerical degeneracy or generation cap then stop
end
return
Function
on the stored rollout of
local rates from ▷ Appendix § 13.§ 5
return , with from (6) at rates
if , else ; and as in Algorithm 1
Best plan and stopping. CMA-ES updates its distribution from the ranks of the unnormalized log-sum-exp of § 4, with a fixed grid and temperature throughout each search. The first population contains the projected nominal seed, whose plan becomes the initial best plan (Algorithm 2). After each generation, the candidate with the lowest objective replaces the best plan when its objective is strictly lower, so the nominal plan is returned when it has the lowest objective of the search. The best plan carries the estimated-verification verdict of its trace, which is recomputed whenever the best plan changes.
Patience is an optional stopping mechanism, enabled in the funnel ablation. A generation counts as progress when the best objective satisfies with
where is the objective of the projected nominal plan and is the best objective at the last generation that counted as progress. is then reset to . It starts at , so the first generation always counts as progress. Small gains accumulate until they clear , and scaling by the improvement already achieved makes the rule invariant to the offset of the objective. is used by this stopping rule and does not enter the objective. The search stops after generations without progress, with when the best plan passes estimated verification and otherwise. The shorter gives a verified plan a few further generations to improve. The search also stops at the generation cap and on numerical degeneracy (Table 5). The search comparison of Appendix § 14.8 disables patience and the generation cap and stops every iterative search on a time budget of 1.5 s per chunk.
| Parameter | Setting |
| Population / parents | 20/10 () |
| Initial step size / generation cap | 1/30 |
| Covariance eigendecomposition | Every generation |
| Seed region | Band with , one global group; mean projected after each update |
| Meaningful improvement | , (relative to achieved improvement) |
| Patience | generations (best plan not verified / verified) |
| Verification | Estimated, window , on the physics-step grid |
| Start allowance | |
| Ranked samples | From the end of the first control step |
| Objective temperature | (PushT), (stacking) |
| Numerical stopping | or |
Table 5. Refinement settings used in all reported refined runs. Population and parents follow the CMA-ES defaults, with the standard log-linear recombination weights Hansen, [35].
Gradient Search on a Differentiable Surrogate
The gradient searches of Table 13 optimize the seed by descending of § 4, with the rollout replaced by a differentiable model of the PushT dynamics and without the band projection.
Table 13: Search method comparison on PushT, all methods and measures. Better/Worse than ours (significant, Appendix § 14.§ 1), or OOD above held-out demonstrations. Score: mean of the maximum and of the final score. DD: drawdown mean and CVaR. Jump: relative velocity jump at chunk boundaries. Executed and Planned: similarity to the demonstrations of the executed path and of the commanded waypoints. †Gradient search on the differentiable model.
| Search | Succ.↑ | CVaR ↑ | Max | Final | Mean | CVaR | KL | LDJ↑ | Jump | OOD%↓ | KID | OOD% | KID |
| Nominal | 31.5 | .000 | .795 | .688 | 33.3 | 67.5 | .363 | −9.92 | .544 | 4.0 | .259 | 3.2 | .286 |
| Adam† | 60.5 | .647 | .927 | .918 | 19.1 | 51.6 | .045 | −10.12 | .652 | 5.8 | .162 | 4.5 | .181 |
| L-BFGS† | 70.0 | .765 | .942 | .938 | 19.5 | 47.4 | .012 | −10.15 | .662 | 12.0 | .196 | 10.7 | .154 |
| Best-of- | 82.5 | .768 | .948 | .940 | 19.9 | 50.5 | .054 | −9.87 | .513 | 4.9 | .175 | 4.0 | .194 |
| CEM | 79.0 | .848 | .954 | .950 | 18.7 | 47.3 | .014 | −10.28 | .600 | 8.0 | .143 | 6.2 | .141 |
| MPPI | 83.0 | .914 | .960 | .958 | 18.5 | 46.8 | .041 | −9.97 | .606 | 10.8 | .224 | 9.8 | .177 |
| CMA-ES, no band | 96.0 | .941 | .963 | .963 | 15.3 | 45.9 | .022 | −10.96 | .682 | 34.1 | 1.39 | 32.5 | .996 |
| CMA-ES, sphere | 84.5 | .794 | .949 | .944 | 19.2 | 49.5 | .033 | −9.62 | .557 | 6.6 | .166 | 5.1 | .152 |
| Ours, | 87.0 | .873 | .957 | .955 | 18.0 | 45.3 | .012 | −9.78 | .558 | 9.5 | .217 | 7.5 | .180 |
| Ours, | 83.0 | .855 | .954 | .951 | 18.3 | 50.3 | .008 | −9.91 | .563 | 9.4 | .177 | 8.2 | .155 |
| Ours, | 86.5 | .877 | .957 | .956 | 18.6 | 47.0 | .012 | −9.93 | .562 | 11.3 | .220 | 9.1 | .163 |
Table 13.
Quasi-static pushing model. The model is the discrete step of the native PushT environment, our Chipmunk2D (Lembcke, [42]) reimplementation of the Diffusion Policy environment (Chi et al., [21]) (Appendix § 12.§ 4), written as a smooth function with the same constants. Only the contact switch and the impulse clamp are smoothed. The state holds the agent position and velocity, the pose of the block’s center of mass and its twist over the last step. Each physics substep () follows Chipmunk’s order. The agent’s kinematic Proportional–Derivative (PD) controller updates with the held target , and . The block starts every substep at rest, since the native space has zero damping, which in Chipmunk removes all body velocity at each step: the block moves only while it is pushed, and the pushing is quasi-static. Contacts are frictionless and inelastic, as in the native environment, whose shapes have zero friction, so they transmit only normal impulses. They are resolved at the positions at the start of the substep by four passes of sequential impulses, between the agent disc and each convex part of the T and between every block vertex and the four walls. For a contact that requires the block point to move along , with arm from the center of mass and block inverse inertia , the impulse along is for the missing normal speed , and accumulated impulses are kept nonnegative. A separate bias channel removes penetration beyond a slop of 0.1 px, as in Chipmunk. Positions are then integrated with the resolved velocities. A waypoint target is held for 10 substeps, one control step.
Smoothing. For the agent disc and a convex part of the T, the signed distance is the differentiable conservative separating-axis distance of Wong et al. (2025),
where is the separation of the disc and the part along the -th of axes, the edge normals of the part and the directions from the disc center to its vertices, and . The log-sum-exp is a smooth maximum over the axes, and the shift keeps it from overestimating the true separation. The contact normal is its normalized gradient, and the two parts of the T are combined by a smooth minimum. Distances to the walls are exact. Each constraint is gated by , px, and its impulse is updated by
a soft constraint whose fixed point does not depend on the number of passes, a hard contact for and no constraint for . The softplus of width px/s replaces the clamp , and the gate in front of it keeps inactive contacts from transmitting any impulse, and the bias channel uses the same gate. Contacts farther than 4.1 px, where gate and bias are both below , are skipped, which changes neither values nor derivatives. On recorded chunks of the nominal policy, the final block position of the model is within 0.16 px of the native simulator in median and 0.5 px at the 90th percentile, in a px workspace. The model is differentiated in double precision.
Gradient through the flow. One evaluation decodes the seed by the 8-step Euler sampler of the flow, maps the result to held targets anchored at the agent’s observed position, rolls them out in the model from the observed start state , and evaluates of § 4 on the model’s trace, with the same frozen funnel, grid and temperature as the population searches. Its gradient with respect to the seed is a single reverse-mode chain: Enzyme (Moses and Churavy, 2020) differentiates the rollout and the objective and then the decoding, and the vector–Jacobian product of the whole sampler is computed by Enzyme on the sampler compiled with Reactant.jl2. The network weights and the conditioning are fixed, and the seed is the optimization variable. Since depends only on the block pose and the plan reaches the block only through agent–block contact, a plan whose agent stays out of the contact range for a whole chunk has an identically zero gradient. The search then stops and keeps the nominal plan.
Optimizers. Both searches start from the nominal seed. Adam uses a learning rate of 0.05 and default moments, so that each seed coordinate moves by at most about 0.05 per iteration. L-BFGS keeps 10 curvature pairs, stores a pair only if , restarts along when the direction is not a descent direction, and selects the step by Armijo backtracking (, halving, at most 10 backtracks) from a unit trial step, with every trial step capped at norm 1 in seed space in place of a trust region. Both stop at the 1.5 s budget, at a stationary point (), on non-finite values, or, for L-BFGS, when the line search fails. The search returns the iterate with the lowest loss on the model, the nominal seed unless some iterate is strictly better.
Planning and execution models. All searches optimize the same funnel objective. The population searches evaluate it on rollouts of the native simulator. The gradient searches evaluate it on rollouts of the smoothed differentiable reimplementation, starting from the observed start state of the chunk, and differentiate through that rollout and the flow decoder. Every loss, gradient, line-search trial and stopping decision of a gradient search comes from this model, which agrees with the native simulator to within 0.16 px in median on recorded chunks. The selected plans of all searches are executed in the native environment.
Policy Architecture and Training
Observations. PushT observes the agent position, the block position, and the block angle as its cosine and sine, six features per step. Stacking observes the end-effector pose, the cube poses, their relative vectors, the measured gripper aperture and last command, and proximity and gripper features, with rotations in the six-dimensional representation of Zhou et al. (2019), 74 features per step. Two-nut assembly observes the end-effector pose, the world pose of each nut, its pose relative to the hand and its offset from its peg, and the measured gripper aperture and last command, 53 features per step.
Demonstration windows and normalization. We train on dense, stride-one windows of the demonstrations, padding at episode boundaries by repeating the first or last sample, and normalize features to with min–max statistics from all policy-training demonstrations. Two choices are specific to our setting. For stacking, the gripper target is the signed command at each control step, while the measured aperture and the previous command are observations. Decoding executes the command through its sign. Rotation blocks are left unnormalized, since they already lie in , before conversion to the RMFM carrier. The policy is trained on all demonstrations. The funnels are fitted on a separate three-way split of the same demonstrations, described in Appendix § 11.§ 2.
Velocity-regression objective. For each window, draw one source sample and one independent flow time uniformly on . The model regresses the corresponding path velocity with normalized weighted squared error,
where indexes waypoint tokens and velocity channels. The action space is a product of a continuous pose space and a binary-like gripper command, which gives two kinds of target: the pose velocity varies smoothly over every window, while the gripper target is nearly constant except at sparse switching events, where its error is large. With uniform weights these rare but large gripper errors can dominate the gradient. Pose-valued policies therefore weight each pose channel by 10 and the gripper channel by 1, so that the pose dominates the loss while the gripper term still contributes. PushT has no gripper and uses uniform weights. The targets are Euclidean path velocities or body twists and gripper rates (Appendix § 9).
Architecture and optimization. On stacking, the conditional vector field is a transformer based on the DiT architecture (Peebles and Xie, 2023) with one action token per waypoint, learned positional embeddings, and cross-attention to observation tokens. It uses 6 blocks, width 384, 8 heads, Multilayer Perceptron (MLP) ratio 4, and Gaussian Error Linear Unit (GELU). Each block has self-attention, cross-attention, and an MLP, with Adaptive Layer Normalization with Zero Initialization (adaLN-Zero) modulation driven by a 64-dimensional sinusoidal flow-time embedding followed by a Dense–Mish–Dense map. We use no dropout. Two-nut assembly uses the same architecture, trained on its own demonstrations. On PushT, the vector field is the conditional one-dimensional U-Net of Diffusion Policy (Chi et al., [21]) over the 24 waypoints, with three levels of 128, 256 and 512 channels, two residual blocks of kernel 5 per level, GroupNorm with 8 groups, and Mish. The flow time is embedded by a 256-dimensional sinusoidal embedding and a Dense–Mish–Dense map and concatenated with the normalized observations of the two history steps, and every residual block applies a FiLM scale and shift predicted from this vector. As in Diffusion Policy, the up path concatenates the outputs of the two coarser levels. We replace the strided convolution by a stride-one convolution followed by subsampling, and the transposed convolution by nearest-neighbour upsampling followed by a convolution, since the strided convolution miscompiles under Reactant. The U-Net has 17.6M parameters. Training uses AdamW with learning rate and , the projected footprint overlap of on times their contact.
weight decay , linear warmup followed by cosine decay to , and Exponential Moving Average (EMA) weights with decay 0.999 for evaluation. Table 6 gives task-specific settings. Training uses Julia (Bezanson et al., [11]), Lux.jl (Pal, 2025), and Reactant.jl.
| PushT | Three-cube stacking | Two-nut assembly | |
| Demonstrations | 206 | 1000 | 1000 |
| Training iterations | 30k | 100k | 100k |
| Batch size / warmup | 128 / 500 steps | 128 / 1000 steps | 128 / 1000 steps |
| Prediction / history | 24 waypoints / 2 steps | 32 waypoints / 5 steps | 32 waypoints / 2 steps |
| Execution horizon | 24 steps | 32 steps | 32 steps |
| State features history | |||
| Network | U-Net (FiLM) | DiT | DiT |
| Flow | OT | RMFM | RMFM |
| Waypoint target | Agent position | EE pose + gripper command | EE pose + gripper command |
| Network channels (in/out) | 2/2 | 13/7 | 13/7 |
| Flow integration | 8 Euler steps | 10 Lie–Euler steps | 10 Lie–Euler steps |
| Control / physics rate | 10 Hz / 100 Hz | 20 Hz / 500 Hz | 20 Hz / 500 Hz |
| Step budget | 400 | 400 | 600 |
| Potential | Pose error (App. § 10.§ 4) | Phased (App. § 10.§ 5) | Phased (App. § 10.§ 6) |
| Funnel split (fraction) | 70/15/15 % | 70/15/15 % | 70/15/15 % |
| Score | Coverage(block, goal) | ||
| Success | Stacked Open | Seated Seated Clear |
Table 6. Task-specific training, execution and evaluation choices. Every chunk is executed in full before replanning.
Environment, Controller, and Execution
Experiments use the initialization conventions in Table 7. Waypoint targets are held over a control period, while tracking and simulation advance at physics substeps. Rollout evaluation includes the initial state and all subsequent physics steps. For stacking, each waypoint is tracked by Damped Least Squares (DLS) Inverse Kinematics (IK) followed by joint-space PD, with gains (Table 8) calibrated once and then fixed: CMA-ES searches the logarithms of the gains (population 12, 15 generations), scoring each candidate by the task success obtained when the controller replays the demonstrated waypoints of 50 demonstrations spread over the dataset. Two-nut assembly uses the same controller on the Sawyer arm, with gains calibrated in the same way on its own demonstrations (Table 8). PushT tracks agent waypoints with PD (, ). The PushT environment reproduces exactly the one of Diffusion Policy (Chi et al., [21]), with the same geometry, physical constants, controller, reward and success predicate. That environment steps Chipmunk2D (Lembecke, [42]) through the Python binding pymunk. We call Chipmunk2D directly from Julia, which removes the Python interpreter from the rollout and lets the candidate rollouts of a generation run in parallel on threads.
| Task | Initialization | Tracking |
| PushT | Hard reset mode: block in , agent in | Position PD |
| Cube Stacking | Each cube placed uniformly in m with uniform yaw, overlaps rejected (the robosuite placement sampler (Zhu et al., 2020)) | IK with joint-space PD |
| Two-Nut Assembly | MimicGen NutAssembly_D0 reset: both nuts placed on the table with uniform yaw, the square nut at , and the round nut at , , robot at the dataset’s initial joint configuration | IK with joint-space PD |
Table 7. Environment initialization and tracking.
| Gain | Stacking | Two-nut assembly |
| Task (position / rotation) | 22.88 / 6.24 | 44 / 28 |
| Task (position / rotation) | 1.43 / 1.53 | 0.81 / 0.39 |
| Joint / | 91.18 / 85.28 | 94.52 / 88 |
| Posture / | 1.40 / 0.37 | 3.50 / 0.42 |
| DLS damping | ||
| Twist limit (linear / angular) | 0.75 m/s / 1.5 rad/s | 0.75 m/s / 1.5 rad/s |
Table 8. IK-PD controller gains for stacking and for two-nut assembly (Sawyer). Twists are clipped to the limits.
Stacking success. Stacking uses the MimicGen StackThree_D1 success predicate. At its first success the robot opens the gripper (0.3 s), retreats 5 cm vertically (0.5 s) and holds still (0.2 s). The episode counts as a success only if the predicate still holds after this sequence, so the tower must stand without support.
Two-nut assembly success. Two-nut assembly uses robosuite’s own check: each nut lies within 30 mm of its peg axis in and in and below table height plus 50 mm, and the gripper meets the native clearance condition. The check is evaluated on the current state, so a placement is not latched, and since it already requires the gripper to be clear, the episode ends at its first success without a release sequence.
Regularity, Verification and Convergence Results
This appendix supports the results of § 3. Appendix § 13.§ 1 states the convergence result in its product form and proves it. Appendix § 13.§ 2 gives conditions under which the task residual is Lipschitz, as the verification bound of Theorem 2 requires, and Appendix § 13.§ 3 proves that bound. The remaining subsections extend Theorem 1 in three directions. A fading start allowance , with , and , keeps the terminal condition and enters the transient bound, and it enables verification from samples at the start of a chunk (Appendix § 13.§ 2). Endpoint errors of at most , from terminal violation of the funnel or from a mismatch between predicted and executed motion, give the recursion , whose endpoint values approach a neighborhood of size (Appendix § 13.§ 4). Progress accumulated over windows of chunks admits preparatory chunks with (Appendix § 13.§ 5).
Convergence: Product Form and Proof of thm:recedinghorizoncontraction
Proposition 4 (Task contraction with iteration-dependent rates). Suppose each selected chunk is executed for the full horizon before replanning, its evaluated task rollout matches execution, and it satisfies (3) with the terminal and transient bounds of (2) for some and . Then, for every ,
and .
Proof. At , funnel satisfaction gives , and iteration yields the product bound. Within iteration , the funnel and the transient bound give .
Proof [Proof of Theorem 1]. Substituting the uniform bounds and into Proposition 4 gives (4). Iterations have a fixed positive duration, so the bound tends to zero with physical time and eventually remains below any positive goal threshold.
Residual Regularity
The verification bound in Theorem 2 uses regularity of the task residual rather than smoothness of the full contact dynamics. The dynamics in (1) can represent stiff compliant-contact dynamics, or flows supplemented by velocity resets in an impulsive model. In either case, the following configuration-level assumptions suffice.
Lemma 5 (Configuration-based residual regularity). Let denote the configuration of the world along the rollout , that is, the generalized coordinates of the robot and the objects, without their velocities. Suppose that, for every candidate plan, is absolutely continuous on with speed bounded almost everywhere by a common . Let be Lipschitz on the reachable set with constant , and let every envelope be Lipschitz with constant at most . Then, uniformly over plans, the task residual is Lipschitz on every sampling interval with
Proof. Bounded speed gives . Consequently,
Adding the envelope’s Lipschitz bound yields the result.
Configuration trajectories can satisfy these assumptions despite velocity jumps. For a composition , a bound on its gradient over a suitable compact neighborhood provides , and Appendix § 10 establishes this regularity for the phased construction. For the learned envelope, is bounded because is bounded on and the predicted parameters are bounded. Numerical sample error and prediction mismatch require separate allowances if the samples are not exact values of the trajectory being verified.
Initial boundary of the funnel. With exact anchoring, , every plan starts with a zero residual at the first sample, . The first interval then contributes to (6), which is positive unless the residual falls at least as fast as the rate allowed for it, so almost no chunk can be verified, regardless of the rest of its trace. The start allowance in (30) lowers the initial residual to and vanishes at , so terminal contraction is unchanged. It is part of the frozen envelope and enters the transient bound through . A learned predictor may output , since demonstrated chunks start exactly on their anchor. We therefore floor the allowance at a fixed fraction of (Appendix § 12.§ 4).
Proof of thm:objectivecertification
On the Lipschitz bound from each endpoint gives . The first term increases and the second decreases in , so their minimum is largest where they are equal, at the value . Taking the maximum over the intervals gives (6), and is funnel satisfaction throughout by the definition of the residual.□
Convergence with a Terminal Error Allowance
Corollary 6 (Practical receding-horizon contraction). Suppose executed chunks satisfy
where and are uniform bounds. Then
and .
Proof. Nonnegativity of permits replacing and by their uniform bounds. Iteration gives the geometric sum in (44), whose limit yields the stated bound.
The allowance can combine terminal residual violation and terminal prediction mismatch. Endpoint contraction needs only the last sample, which sampled verification already covers under matched full-chunk execution. Continuous-time satisfaction follows from (7). A whole-trajectory practical bound must also account for transient error.
Notes on the Theorems
Learned additive envelopes and Theorem 1. All profiles in (30) take values in , so the learned envelope satisfies the transient bound of (2) with
The predictor is a continuous network on a bounded feature domain with bounded allowance outputs, so for some constant , and
An additive allowance corresponds to the relative allowance , which grows as decreases. For example, a fixed allowance of 0.1 is 10% of and 1000% of . The bound therefore holds on the region , and Theorem 1 applies to additive funnels until reaches the positive level . This scope matches our evaluation, which judges completion by the native success predicate of each task. The multiplicative family has a relative allowance by construction and satisfies the bounded-allowance condition at every level of . If, in addition, for a continuous, strictly increasing with , convergence of implies convergence in distance to .
Progress without a uniform rate. A learned funnel may request no endpoint progress for some chunks, , for instance while the robot regrasps or moves to the next object. The rate in (4) then does not apply, because it assumes at every iteration. The product bound in (42) still holds for any . The following proposition shows that convergence still holds when requested progress accumulates, either in total or within windows of chunks.
Proposition 7 (Progress over windows). Suppose every executed chunk satisfies the funnel (3) with the envelope conditions (2), under the execution assumptions of Theorem 1, and for all .
For every , . Hence, for any tolerance , as soon as .
If there are and such that whenever , then for all .
Proof. (i) Since , (42) gives , and within chunk the transient bound adds at most a factor . (ii) Terminal contraction gives , so is nonincreasing. Summing over a window that starts outside the goal set gives . At most such windows fit before the boundary value falls below , and monotonicity keeps it there.
Statement (i) needs no lower bound on the individual rates, only that their sum eventually exceeds the stated level. Statement (ii) admits chunks with , provided some progress is requested in every window of chunks. The predictor does not enforce this condition, and it can be checked along executed episodes. Both statements concern chunk boundaries. Within chunk the task potential stays below .
Local rates and their estimates. In Theorem 2, bounds the rate of the residual on interval . We estimate the rate of each interval from the largest nearby secant slope. The local rate is the largest secant slope among the intervals whose midpoints lie within a window of the midpoint of interval , with the adjacent intervals always included. Substituting into (6) gives estimated verification, the verdict that the search uses for its patience and that the main text reports. The neighbouring intervals supply the rate information: the secant of interval alone returns in (6), which is sampled verification. Since is at least the secant of its own interval, a chunk that passes estimated verification also passes sampled verification. The estimate assigns a fast change of the residual to the intervals near where it occurs, and its resolution is set by the sample spacing and the window . The guarantee of Theorem 2 applies when the rates upper-bound the true residual rate on each interval, for instance with from Lemma 5.
Search objective and verification. The log-sum-exp of § 4 lies between and , so implies sampled verification. and the verdict serve separate purposes. aggregates the sampled residuals smoothly and ranks the candidates. The verdict of each plan is computed from its samples through (6) with the local rates, which concern the regularity of the residual over physical time.
Evaluation Statistics and Additional Results
Paired Bootstrap Intervals
Each comparison uses matched episodes. For a given episode index, all compared configurations share the environment initial condition, the random seeds of the environment and the policy, and the initial flow-matching source draw. The funnel ablation uses episodes and the search comparison .
For each of 4000 bootstrap replicates, we sample episode indices with replacement and use the same indices for both configurations. A draw such as [2, 2, 5, 1, . . . ] selects those episodes, duplicates included, from both configurations. We recompute the metric for each configuration on the sampled episodes and take the difference from the reference configuration, which is endpoint-only in the funnel ablation and our search in the search comparison. The 2.5th and 97.5th percentiles of these differences give the 95% percentile-bootstrap interval. We report it together with the point estimate, the difference of the metric between the two configurations on the original paired episodes, and call a difference significant when its interval excludes zero. Pairing retains the correspondence between starting conditions, so the variation in episode difficulty is shared by the two configurations. The intervals describe the uncertainty across the evaluated initial conditions for the reported policy and execution setup. Figure 6 and Table 14 report these intervals, and the shading of Table 2 and Table 13 follows them, except for the OOD column, which is shaded when the rate lies above the 95% interval of the held-out demonstrations (Appendix § 14.8).
Figure 6. Paired differences from endpoint-only on the same 400 initial conditions: point estimate on the original paired episodes and 95% percentile bootstrap interval; filled markers exclude zero. Success in episodes, drawdown in score points; on two-nut assembly, drawdown and final score are those of the V-score (Appendix § 14.§ 4). In the legends, Endpoint is endpoint-only, Calibrated the calibrated global funnel and (MPC) the objective; final reward is the final score.
Table 14: Paired differences from our search (method minus ours) on the same 200 initial conditions: point estimate on the original paired episodes and 95% percentile bootstrap interval, in bold when the interval excludes zero. Success and drawdown in points. Positive is better for success, score and LDJ, and worse for drawdown, KL and Jump.
| Search | Succ. [pts] | Mean | CVaR | Mean | CVaR | KL | LDJ | Jump |
| Nominal | −55.0 [−62.5, −47.0] | −.267 [−.312, −.224] | −.877 [−.930, −.777] | +14.7 [+11.6, +17.9] | +20.5 [+11.6, +29.4] | +.352 [+.208, +.554] | +0.01 [−0.09, +0.12] | −.018 [−.046, +.010] |
| Adam† | −26.0 [−34.0, −18.0] | −.038 [−.058, −.023] | −.230 [−.398, −.095] | +0.5 [−1.3, +2.5] | +4.5 [−1.1, +9.6] | +.034 [−.083, +.086] | −.19 [−.32, −.06] | +.091 [+.060, +.122] |
| L-BFGS† | −16.5 [−24.5, −8.5] | −.017 [−.033, −.006] | −.112 [−.252, −.015] | +1.0 [−0.7, +2.7] | +0.4 [−4.7, +5.2] | +.000 [−.110, +.027] | −.22 [−.36, −.07] | +.100 [+.064, +.137] |
| Best-of- | −4.0 [−11.0, +3.0] | −.016 [−.034, +.000] | −.109 [−.215, −.006] | +1.3 [−0.5, +3.0] | +3.5 [−1.6, +8.3] | +.042 [−.077, +.137] | +0.06 [−0.05, +0.16] | −.049 [−.075, −.023] |
| CEM | −7.5 [−15.0, +0.0 |
Table 14.
For tail metrics, each replicate identifies the lowest-scoring or largest-drawdown fraction of the resampled episodes separately for each configuration and averages that fraction before taking the difference. An episode can therefore belong to the tail of one configuration and to the bulk of the other, while both resampled datasets are built from the same episode indices.
Metric Definitions
Final-score CVaR. The mean final score over the lowest-scoring 10% of episodes. Higher is better.
Maximum drawdown and its CVaR. The maximum drawdown of an episode is the largest fall of the score below its earlier peak, , in points (). The trace 0.2, 0.7, 0.4, 0.8 has a drawdown of 0.3, or 30 points. CVaR is the mean drawdown over the 10% of episodes with the largest drawdown, and CVaR over the largest 5%. Lower is better. The subscript is the quantile level at which the tail starts, so CVaR of a score and CVaR of a drawdown both average the worst 10% of episodes.
KL. compares the distribution of the peak score with that of the final score across episodes. Both are histograms with 20 bins over the joint range of the two scores and a pseudocount of 0.5. A lower value means that the episodes end close to their peak. Kullback–Leibler (KL) complements the drawdown at the level of distributions: it compares the peak and final scores across episodes, and the drawdown measures the loss within each episode.
Verification rate. The share of complete executed chunks that pass estimated verification against the funnel of their configuration. The denominator counts the chunks executed over their full horizon .
V-score. On two-nut assembly, the V-score is , with the potential at the reset state (Appendix § 14.§ 4).
Smoothness and similarity to the demonstrations. Smoothness is the LDJ ([6]) of the executed pusher path within chunks, where higher is smoother. Similarity to the demonstrations is the share of executed 24-step windows that are out of distribution under a nearest-neighbor test against the training demonstrations ((Sun et al., 2022)), with the settings of Appendix § 14.8.
Complete Funnel Ablation
Table 9 extends Table 1 to every configuration of the funnel ablation, with the mean final score and the verification of the nominal plans of the same planning calls. Plateaus at allow to at least double inside a chunk, a level above the values that rollouts reach. Their results closely follow those of endpoint-only, and their equal sampled and estimated verification shares show that the endpoint is the binding condition (Appendix § 14.7).
Table 9: Funnel ablation, all configurations, 400 episodes per configuration. Shading: best, second and third refined configuration in each column. Verified: share of complete executed chunks (Executed) and of planning calls whose nominal plan (Nominal) passes estimated verification (Appendix § 14.7).
| Funnel | Success [%] ↑ PushT | Success [%] ↑ Stack. | Final score ↑ Mean PushT | Final score ↑ Mean Stack. | Final score ↑ CVaR PushT | Final score ↑ CVaR Stack. | Max drawdown [pts] ↓ Mean PushT | Max drawdown [pts] ↓ Mean Stack. | Max drawdown [pts] ↓ CVaR PushT | Max drawdown [pts] ↓ CVaR Stack. | KL ↓ PushT | KL ↓ Stack. | Verified [%] ↑ Executed PushT | Verified [%] ↑ Executed Stack. | Verified [%] ↑ Nominal PushT | Verified [%] ↑ Nominal Stack. |
| Nominal | 31.3 | 77.0 | .638 | .637 | .000 | .000 | 40.0 | 8.5 | 86.9 | 46.1 | .472 | .181 | n/a | n/a | ||
| Endpoint-only | 86.8 | 86.0 | .923 | .804 | .560 | .084 | 28.3 | 6.8 | 62.8 | 46.1 | .053 | .060 | n/a | n/a | ||
| No envelope | 60.5 | 85.5 | .855 | .744 | .218 | .103 | 23.4 | 5.8 | 54.2 | 41.8 | .153 | .065 | n/a | n/a | ||
| 80.0 | 82.0 | .910 | .715 | .499 | .000 | 22.6 | 6.4 | 54.4 | 43.4 | .052 | .084 | n/a | n/a | |||
| Plateau, | 73.0 | 83.8 | .905 | .771 | .494 | .075 | 23.9 | 6.9 | 56.7 | 46.2 | .098 | .065 | 73.3 | 41.9 | 48.7 | 40.0 |
| Plateau, | 86.5 | 86.5 | .920 | .803 | .529 | .091 | 27.9 | 7.1 | 62.9 | 46.8 | .060 | .045 | 68.8 | 40.9 | 45.8 | 35.4 |
| Plateau, | 86.8 | 85.8 | .924 | .805 | .568 | .097 | 28.1 | 6.7 | 62.4 | 45.7 | .053 | .054 | 69.0 | 40.6 | 46.2 | 35.4 |
| Linear | 54.5 | 78.8 | .839 | .662 | .194 | .000 | 24.3 | 7.6 | 54.7 | 44.3 | .219 | .108 | 0.5 | 3.3 | 5.5 | 9.7 |
| Calibrated per stage | – | 82.8 | – | .792 | – | .101 | – | 7.6 | – | 48.5 | – | .102 | – | 57.6 | – | 47.2 |
| Calibrated global | 88.5 | 80.5 | .927 | .717 | .587 | .001 | 27.4 | 7.5 | 62.9 | 46.2 | .038 | .107 | 60.5 | 61.2 | 15.4 | 52.5 |
| Learned add., | 84.8 | 85.0 | .925 | .799 | .613 | .162 | 22.9 | 7.6 | 52.3 | 47.0 | .029 | .056 | 38.0 | 44.3 | 7.5 | 23.6 |
| Learned add., | 71.8 | 82.3 | .900 | .775 | .480 | .065 | 23.1 | 6.6 | 53.7 | 44.8 | .126 | .058 | 56.2 | 50.8 | 18.6 | 35.4 |
| Learned add., | 74.3 | 82.3 | .902 | .767 | .474 | .025 | 22.6 | 7.0 | 52.6 | 44.8 | .126 | .101 | 62.9 | 54.3 | 24.6 | 41.9 |
| Learned mult., | 76.5 | 85.8 | .910 | .796 | .542 | .095 | 23.1 | 7.0 | 52.5 | 46.3 | .169 | .060 | 40.5 | 42.1 | 12.2 | 23.5 |
| Learned mult., | 71.8 | 82.0 | .906 | .771 | .529 | .067 | 23.2 | 8.2 | 52.0 | 47.6 | .091 | .083 | 62.6 | 49.2 | 28.6 | 34.2 |
| Learned mult., | 63.8 | 84.0 | .887 | .775 | .424 | .107 | 23.5 | 5.7 | 54.0 | 40.5 | .145 | .056 | 70.7 | 54.2 | 33.1 | 43.6 |
Table 9.
Two-Nut Assembly
We repeat the funnel ablation on MimicGen’s two-nut assembly ((Mandlekar et al., 2023)), in which a Sawyer arm threads a square nut onto one peg and then a round nut onto the other. The policy is the DiT-RMFM of stacking, trained on the task’s 1000 demonstrations, and it is refined against the phased potential of Appendix § 10.§ 6, against which every learned and calibrated funnel was fitted. Search and protocol are those of the main text, and Table 6–Table 8 give the remaining settings.
Measuring progress. PushT and stacking are scored by a measure separate from . Two-nut assembly has no such measure finer than the share of seated nuts, , which falls in only 2 of the 6400 episodes and therefore says little about transient regressions. We report success and this native score, neither of which depends on , and compute the final score, drawdown and KL on the V-score , where is the potential at the reset state, the same in every episode. The V-score derives from the potential that also defines the refinement objectives, so its statistics describe how each configuration uses that potential.
Results. Refinement again improves clearly on nominal execution. It raises success from 80.3% to 84.5% with endpoint-only and to 85–89% with , , the learned funnels and the plateau at (Table 10). Endpoint-only also raises the native score from .873 to .915 and lowers the of the V-score drawdown from 43.2 to 30.7 points. The configurations that bound the interior stay at this level of progress retention, with confidence intervals for the V-score drawdown against endpoint-only that contain zero. The learned multiplicative funnel at has the lowest values, a of 21.2 points and a KL of .034. The plateau at solves significantly more episodes than endpoint-only, 17 more. The calibrated funnels and the linear funnel lie close to nominal execution. They are significantly below endpoint-only in the final -score and its , and the linear funnel solves 24 fewer episodes, as on stacking. The learned funnels keep the success of endpoint-only and make about 40% of the executed chunks pass estimated verification, compared with 20 to 40% of the nominal plans (Appendix § 14.7). Figure 5 shows a pronounced case of the failures that refinement resolves. From the same initial condition, the nominal execution keeps pushing against the square nut and stays there for the rest of the episode. The refined execution grasps the square nut, seats it on its peg, and then picks up the round nut and seats it on the other peg, which completes the task.
| Funnel | Configuration | Success [%] ↑ | Native score mean ↑ | Final ↑ Mean | Final ↑ CVaR10 | Drawdown [pts] ↓ Mean | Drawdown [pts] ↓ CVaR90 | KL ↓ | Executed ↑ | Nominal |
| Nominal | 80.3 | .873− | .875− | .205− | 5.4− | 43.2− | .192− | n/a | ||
| Endpoint-only | 84.5 | .915 | .923 | .401 | 3.6 | 30.7 | .060 | n/a | ||
| No envelope | 86.8 | .927 | .928 | .394 | 3.4 | 30.6 | .080 | n/a | ||
| No envelope | 86.3 | .920 | .923 | .358 | 2.8 | 24.3 | .057 | n/a | ||
| Plateau | 83.0 | .907 | .923 | .401 | 3.5 | 30.2 | .055 | 32.5 | 32.9 | |
| Plateau | 84.3 | .912 | .919 | .390 | 4.1 | 35.4 | .071 | 31.5 | 32.2 | |
| Plateau | 88.8+ | .936+ | .935 | .410 | 3.1 | 25.3 | .060 | 32.7 | 33.5 | |
| Linear | 78.5− | .877− | .881− | .323− | 4.9 | 41.3 | .144− | 1.6 | 13.9 | |
| Calibrated | per stage | 80.5 | .884− | .894− | .300− | 4.7 | 40.5 | .113 | 62.2 | 60.0 |
| Calibrated | global | 81.5 | .895 | .898− | .338− | 4.7 | 40.9 | .133− | 44.1 | 44.2 |
| Learned add. | 86.5 | .925 | .926 | .372 | 2.8 | 23.3 | .047 | 37.4 | 20.2 | |
| Learned add. | 86.5 | .922 | .927 | .353 | 3.2 | 27.3 | .061 | 41.2 | 30.9 | |
| Learned add. | 87.8 | .927 | .927 | .338 | 3.4 | 28.9 | .085 | 44.0 | 39.3 | |
| Learned mult. | 88.3 | .934 | .937 | .432 | 2.6 | 21.2 | .034 | 38.9 | 21.8 | |
| Learned mult. | 85.3 | .915 | .923 | .349 | 2.6 | 22.0 | .055 | 41.5 | 31.1 | |
| Learned mult. | 87.3 | .926 | .921 | .349 | 3.4 | 29.2 | .083 | 44.7 | 39.5 |
Table 10. Funnel ablation on two-nut assembly, 400 episodes per configuration. Native: share of seated nuts. V-score: . Shading: best, second and third refined configuration in each column. : significantly better/worse than endpoint-only (paired 95% bootstrap). Verified: complete executed chunks and nominal plans passing estimated verification (Appendix § 14.7).

Figure 5. Representative refined (top) and nominal (bottom) episodes on two-nut assembly from the same initial condition, time running left to right. The refined execution seats the square nut and then the round one; the nominal execution never lifts the square nut and stays stuck at it for the rest of the episode.
Why terminal contraction suffices here. Progress on two-nut assembly comes in two discrete steps, one per seated nut, and the phased potential decreases along the motions that achieve them. Requiring to fall from one chunk boundary to the next therefore already selects the plans that advance toward the next seat or keep what was achieved. A nut dropped within a chunk ends it at a higher , which terminal contraction rejects, as a toppled tower does on stacking. The -score is consistent with this. The drawdown under the interior constraints equals that under endpoint-only within the confidence intervals, and its largest values, 40 to 48 points, have the size of the progress of a whole nut. Two-nut assembly is the opposite case to PushT. On PushT the task score registers progress inside a chunk, and the interior bound improves retention (§ 5). On two-nut assembly the interior bound of the funnel contributes estimated verification of the transient at the success level of endpoint-only.
Lower Tails of the Outcome
Figure 6 reports, for each objective of Table 1, the paired difference from endpoint-only on the same 400 initial conditions in success, in the and of the maximum drawdown, and in the of the final score. On PushT, every objective except the calibrated funnel lowers the drawdown significantly, by 6 to 10 points, and every one except the learned additive funnel at also loses successes significantly, from 27 episodes for to 129 for the linear funnel. The learned additive funnel at lowers the by 10.4 points and the by 12, at a success statistically on par with endpoint-only. Lowering the drawdown tail is thus common to the objectives that constrain the interior, and this funnel combines it with the success of endpointonly. On stacking, only the learned multiplicative funnel at lowers the drawdown tail significantly, by 5.7 points in CVaR and 3.5 in CVaR, at a success statistically on par with endpoint-only, while the calibrated global funnel and the linear funnel lose successes significantly. On two-nut assembly, the confidence intervals for the V-score drawdown tail against endpoint-only all contain zero. The learned additive funnel at and have the largest reductions of its CVaR, 7.4 and 6.4 points, and the calibrated funnel and the linear funnel the largest increases, about 10 points. Both of the latter lower the CVaR of the final V-score significantly, and the linear funnel also loses 24 episodes. Among the configurations not shown, only the plateau at gains successes significantly (Appendix § 14.§ 4). Refinement leaves the motion as smooth as endpoint-only does, with the log dimensionless jerk of executed chunks within 0.2 of endpoint-only’s for every funnel on PushT and stacking, and within 0.13 on two-nut assembly.
Figure 7–Figure 9 show the drawdown at every tail fraction, of which Table 1 reports only the mean and CVaR. On stacking (Figure 7), most episodes give back almost nothing, and every configuration, nominal execution included, has a step just below 50 points, the drawdown of an episode that loses the top placement after reaching it. Refinement changes the number of such episodes and leaves the size of the loss unchanged. The learned multiplicative funnel and lie lowest between about 10 and 45 points, which is where their lower CVaR comes from. On PushT (Figure 9a), nominal execution lies far above every refined configuration at every tail fraction. Endpoint-only is the highest refined curve throughout, the calibrated global funnel nearly coincides with it down to the worst 10%, and every objective that constrains the interior of the chunk sits about 8 to 10 points below it over the whole tail, with the learned additive funnel lowest in the extreme tail. On stacking (Figure 9b), the configurations differ by a few points. The learned multiplicative funnel and stay lowest from the worst half of the episodes down to about the worst 5%. Beyond that, each curve rests on a handful of episodes (4 at ), too few to order the configurations. On two-nut assembly (Figure 8 and Figure 9c), most episodes give back only a few points, and the configurations separate by how many episodes later lose a large part of their progress: about 10% under nominal execution, the calibrated funnel and the linear funnel, about 7% under endpoint-only and most other objectives, and 5 to 6% under the learned additive funnel at and , which lie lowest from the worst 50% down to about the worst 5% (Figure 9c). Beyond that, every curve rests on drawdowns of 40 to 48 points, close to the 45 points of that the square nut accounts for at rest, and the curves lie too close to order the configurations.
Figure 7. Stacking: share of episodes whose maximum drawdown exceeds , as for PushT in Table 1 (right).
Figure 8. Two-nut assembly: share of episodes whose maximum V-score drawdown exceeds .
Figure 9. Mean maximum drawdown of the worst of episodes, CVaR at tail fraction , for the objectives of Table 1; the dotted lines mark and . On two-nut assembly (c) the drawdown is that of the -score. In the legends, Endpoint is endpoint-only, Calibrated the calibrated global funnel and (MPC) the objective.
Choice of the Potential
We ask how much task structure the potential needs. On stacking we refine against three potentials, each with a fixed additive funnel and with its own learned additive funnel at of matched size, under the search of Table 5. The terminal-tolerance potential is a simple potential that scores the final geometry of the two placements. The two phased potentials follow the construction of Appendix § 10 and guide the lift, the carry and the transition between the placements. The first is the potential of the main experiments, (25), which builds both placements from the residual of (23) with its finer lowering bands and alignment basin. The second builds both placements from the gate residual , which has wider bands and no alignment basin. The ablation uses the 400 initial conditions and seeds of the main funnel ablation, and the learned-funnel configuration of the residual- potential is the one reported in Table 9.
The simple potential alone leaves refinement below nominal execution. With the terminal-tolerance potential, refinement reaches 63.0% success with the fixed funnel and 50.0% with the learned funnel, compared with 77.0% for nominal execution, and its mean drawdown under the learned funnel is 13.4 points, compared with 8.5 (Table 11). With both phased potentials, refinement improves on nominal execution. With the learned funnel, the residual- potential of the main experiments reaches 82.3% success and the gate-residual potential 86.0%, with mean drawdowns of 7.0 and 6.0 points. The learned funnel adds 7.8 and 5.5 points of success over the fixed funnel for the two potentials. These results support encoding the intermediate task structure in the potential: one that follows the task along the way lets the search select motions that advance it. Within the phased construction, the gate residual, with wider bands and no alignment basin, performs at least as well as the residual , so this coarser residual is sufficient on this task.
| Potential | Fixed funnel | Learned funnel | Mean | Median | CVaR |
| Nominal | 77.0 | 8.5 | 0.75 | 46.1 | |
| Terminal tolerance | 63.0 | 50.0 | 13.4 | 6.4 | 42.9 |
| Phased, gate residual | 80.5 | 86.0 | 6.0 | 0.31 | 43.0 |
| Phased, residual (main) | 74.5 | 82.3 | 7.0 | 0.51 | 44.8 |
Table 11. Potential ablation on three-cube stacking, RMFM policy, with a fixed additive funnel and a learned additive funnel at of matched size, on the 400 initial conditions and seeds of the main funnel ablation. The phased residual- potential is the potential of the main experiments, and its learned-funnel entries are those of Table 9. Success in percent of initial conditions. Drawdown statistics, in score points, are those of the learned-funnel configurations.
Verification Details
A funnel with an interior envelope gives a condition on the transient that can be checked on each chunk. Verification applies to the configurations with an interior envelope, and endpoint-only is covered by its endpoint condition. For these configurations, Table 12 reports the share of complete executed chunks that pass sampled verification and estimated verification. As a reference, it also reports the share of planning calls whose nominal plan passes estimated verification on its predicted trace. Estimated verification uses the window s on the physics-step grid of the rollout.
| Task | Funnel | Executed | Nominal | |
| Sampled | Estimated | Estimated | ||
| PushT | Plateau, | 73.3 | 73.3 | 48.7 |
| Plateau, | 68.9 | 68.8 | 45.8 | |
| Plateau, | 69.0 | 69.0 | 46.2 | |
| Linear | 15.5 | 0.5 | 5.5 | |
| Calibrated, global | 71.2 | 60.5 | 15.4 | |
| Learned add., | 44.1 | 38.0 | 7.5 | |
| Learned add., | 64.2 | 56.2 | 18.6 | |
| Learned add., | 78.7 | 62.9 | 24.6 | |
| Learned mult., | 42.6 | 40.5 | 12.2 | |
| Learned mult., | 65.0 | 62.6 | 28.6 | |
| Learned mult., | 77.8 | 70.7 | 33.1 | |
| Stacking | Plateau, | 41.9 | 41.9 | 40.0 |
| Plateau, | 40.9 | 40.9 | 35.4 | |
| Plateau, | 40.6 | 40.6 | 35.4 | |
| Linear | 11.3 | 3.3 | 9.7 | |
| Calibrated, per stage | 84.1 | 57.6 | 47.2 | |
| Calibrated, global | 85.1 | 61.2 | 52.5 | |
| Learned add., | 55.0 | 44.3 | 23.6 | |
| Learned add., | 73.3 | 50.8 | 35.4 | |
| Learned add., | 81.1 | 54.3 | 41.9 | |
| Learned mult., | 51.5 | 42.1 | 23.5 | |
| Learned mult., | 71.0 | 49.2 | 34.2 | |
| Learned mult., | 81.6 | 54.2 | 43.6 | |
| Two-nut assembly | Plateau, | 32.5 | 32.5 | 32.9 |
| Plateau, | 31.5 | 31.5 | 32.2 | |
| Plateau, | 32.7 | 32.7 | 33.5 | |
| Linear | 14.2 | 1.6 | 13.9 | |
| Calibrated, per stage | 96.3 | 62.2 | 60.0 | |
| Calibrated, global | 97.1 | 44.1 | 44.2 | |
| Learned add., | 67.2 | 37.4 | 20.2 | |
| Learned add., | 77.7 | 41.2 | 30.9 | |
| Learned add., | 86.9 | 44.0 | 39.3 | |
| Learned mult., | 59.6 | 38.9 | 21.8 | |
| Learned mult., | 73.4 | 41.5 | 31.1 | |
| Learned mult., | 86.2 | 44.7 | 39.5 |
Table 12. Verification against each configuration’s own funnel, in percent of chunks, U-Net-OT on PushT and DiT-RMFM on stacking and two-nut assembly. For the plateaus only the endpoint binds, so their sampled and estimated shares coincide. Executed: complete executed chunks. Nominal: planning calls whose nominal plan passes estimated verification on its predicted trace, counting every call, including the last, cut-short chunk of each episode.
Estimated verification is stricter than sampled verification by up to 16 points on PushT and 27 points on stacking, which shows how much the bound between samples contributes to the verdict, and the difference grows with the leniency of the learned funnels. For the plateaus the two shares agree to within a point, since their envelope lies far above inside the chunk and the endpoint is the binding condition. Under the learned funnels, the executed chunks pass estimated verification more often than the nominal plans of the same calls, by 28 to 38 points on PushT and by 11 to 21 points on stacking. Under the linear funnel, few candidates meet the constraint, and the executed share is 0.5% on PushT and 3.3% on stacking. The nominal share counts every planning call on its predicted trace, including the last chunk of each episode, and the executed share counts complete executed chunks.
Two-nut assembly follows the pattern of stacking. The difference between sampled and estimated verification reaches 53 points for the calibrated global funnel, and under the learned funnels the executed chunks pass estimated verification more often than the nominal plans, by 5 to 17 points. The sampled and estimated shares of the plateaus coincide, as on the other tasks.
Search Method Comparison
Compared methods. All methods of Table 13 refine the same policy, the PushT U-Net of Appendix § 12.§ 3 used in the funnel ablation, against the same objective, the plateau funnel at with , and on the control grid, and run on 200 shared initial conditions with the hard reset of Table 7. The population searches score every candidate by a rollout in the native simulator and use a population of 20. Plain CMA-ES samples the seed without projection. CMA-ES on the band, CEM (elite fraction 0.2, smoothing 0.1, minimum standard deviation 0.05), MPPI (temperature 0.1) and best-of- use the typical-set projection of § 4 unchanged. Every sampled seed is mapped by of (9), with one global group, before it is decoded, and the search mean is projected after each update. CEM, MPPI, best-of- and ours use , and two further configurations of ours use the tighter bands . The sphere configuration fixes both radii of the band to the typical radius of (36), the projection of standardized CMA-ES (Stölzle et al., 2026). Best-of- decodes one batch of 200 projected draws, the nominal seed first, and keeps the best. The gradient searches of Appendix § 12.§ 2 move the seed by their own steps and are not projected. Every iterative search runs on a time budget of 1.5 s per chunk, with patience and the generation cap disabled. The clock is checked after every generation or iteration, so a search exceeds it by at most one. A gradient search can still stop earlier, on a stationary gradient, a failed line search, or a plan that never reaches the block.
Similarity to the demonstrations. We measure how closely the executed pusher paths of a search resemble the demonstrated ones. Executed pusher paths are cut into 24-step windows at the chunk boundaries, expressed relative to the pusher position at the start of the window, and projected on a 32-component Principal Component Analysis (PCA) of the windows of the training demonstrations.
A window is out of distribution when the mean distance to its 5 nearest training windows exceeds the 95th percentile of the same distance over held-out demonstration windows, and Kernel Inception Distance (KID) [12] is computed against the training windows in the same space. Held-out demonstrations, cut at the chunk boundaries in the same way, have an OOD rate of 9.6% (95% interval 5.4–15.4%). Only unconstrained CMA-ES exceeds this interval. It also has a KID of 1.39, against 0.14–0.26 for every other method, nominal execution included. Among the band widths, only the sphere separates from in OOD rate. KID has wide episode-bootstrap intervals (0.08–0.44 for ours) and does not separate the other methods. The commanded waypoints give the same ranking (Table 13). The similarity scores and LDJ average over the chunks that each method executes, and successful methods end sooner, so the methods average different stretches of the task. Nominal execution therefore has a higher KID than the searches despite its lowest OOD rate: its windows include many more stretches of long failing episodes.
Outcome and smoothness. Table 14 gives the paired intervals behind Table 13. Here we add the comparisons that the main text does not discuss. Unconstrained CMA-ES is also significantly better than ours in the mean final score and the mean Drawdown (DD), and the sphere has a significantly lower mean final score. No search differs significantly from ours in the drawdown tail or in KL. Within chunks, unconstrained CMA-ES is the least smooth search (LDJ −1.03 against ours), followed by CEM and the gradient searches, while the sphere (+0.31) and the band at (+0.15) are significantly smoother. At chunk boundaries, unconstrained CMA-ES, the gradient searches, CEM and MPPI jump significantly more than ours, the sphere does not differ from it, and best-of- jumps significantly less (−0.049). At the final score is slightly but significantly lower, in mean (−0.005) and (−0.022). That interval is narrow because both methods end the same episode with score zero, which cancels in the paired resamples. The time to finish separates the methods more clearly than the mean score. An episode stops at its first success, when the score first exceeds 0.95, and an episode that approaches the threshold runs to its step budget with a similar score. On the band, the maximum score and the mean drawdown of all methods lie within 0.01 and 1.3 points of ours (Table 13). Over the episodes that each method solves, resampled jointly with ours, the narrower bands need 17 more steps (: [+5, +28]; : [+7, +28]), the sphere 38 ([+26, +50]) and best-of- 77 ([+63, +91]). This average is taken over the solved episodes of each method. Counting failures at the 400-step limit, the episodes of best-of- run 73 steps longer than ours ([+55, +90]) and those of the sphere 37 ([+18, +55]). Best-of- and the sphere therefore combine the most demonstration-like motion with longer times to completion, at a similar score and drawdown.
Gradient searches. Beyond success, L-BFGS and Adam are significantly worse than ours on every score measure. The model’s per-chunk error is small and compounds over contact switches. Adam, whose step moves each seed coordinate by at most about 0.05 per iteration, stays close to the demonstrations (5.8% OOD) but solves the fewest episodes. A derivative-free search also applies unchanged to simulators that cannot be differentiated.
Computational Cost
Setup. Refinement splits its work between the GPU and the CPU. The flow decodes the whole population of a generation in one batched call on the GPU, with its integration steps unrolled and compiled into a single kernel by Reactant.jl. The decoded plans are then rolled out on CPU threads, where each worker process keeps a pool of simulator copies, resets them to the planning state, and evaluates the candidates in parallel. All timings were measured on a workstation with a 32-core AMD Ryzen Threadripper 9970X and an NVIDIA RTX PRO 5000 Blackwell GPU. Each experiment runs several worker processes that share the GPU, with the worker layouts given in Table 15 and Table 16. Times are wall-clock per planning call, including flow decoding, rollouts and the search, and exclude compilation: the first episode of each worker, during which compilation may occur, is left out, and in the search ablation the samplers were compiled beforehand.
| Funnel | PushT | Stacking | Two-nut assembly | |
| Nominal | 0.01 | 0.01 | 0.01 | |
| Endpoint-only | 1.17 | 3.84 | 6.18 | |
| No envelope | 0.77 | 2.02 | 3.26 | |
| 1.41 | 4.97 | 8.34 | ||
| Plateau | 1.06 | 3.93 | 6.11 | |
| 1.12 | 3.76 | 6.20 | ||
| 1.14 | 4.09 | 6.79 | ||
| Linear | 1.10 | 4.75 | 6.96 | |
| Calibrated | per stage | – | 3.38 | 4.53 |
| global | 1.30 | 3.44 | 4.87 | |
| Learned add. | 1.14 | 4.02 | 5.94 | |
| 1.02 | 3.80 | 5.75 | ||
| 0.94 | 3.74 | 5.60 | ||
| Learned mult. | 1.17 | 3.90 | 5.84 | |
| 1.00 | 3.81 | 5.62 | ||
| 0.99 | 3.81 | 5.56 | ||
| Workers threads | 10 4 | 14 4 | 14 4 |
Table 15. Wall-clock planning time per chunk [s] in the funnel ablation. Each refined chunk is a CMA-ES search with population 20, at most 30 generations and the patience of Table 5. Nominal execution decodes one plan. PushT uses the U-Net-OT policy, stacking and two-nut assembly the DiT-RMFM policy.
| Search | Time [s] | Iterations | Evaluations |
| Nominal | 0.01 | – | 1 |
| Adam† | 1.33 | 20.3 | 21 |
| L-BFGS† | 1.35 | 14.5 | 36 |
| Best-of- | 0.20 | 1 | 200 |
| CEM | 1.52 | 40.4 | 808 |
| MPPI | 1.52 | 42.0 | 841 |
| CMA-ES, no band | 1.52 | 40.8 | 815 |
| CMA-ES, sphere | 1.52 | 40.6 | 811 |
| Ours, | 1.5 | 40 | 800 |
| Ours, | 1.5 | 40 | 800 |
| Ours, | 1.52 | 40.3 | 806 |
Table 16. Compute in the PushT search ablation, ten worker processes of four threads sharing one GPU. Iterations: generations, batches or gradient steps per chunk. Evaluations: plans evaluated per chunk.
Funnel ablation. Refinement costs 2.0 to 5.0 s per chunk on stacking, 3.3 to 8.3 s on two-nut assembly and 0.8 to 1.4 s on PushT, against 0.01 s for the nominal policy (Table 15). Every candidate costs one rollout regardless of the objective, so the objectives differ in cost through when the search stops: it ends when its best plan stops improving meaningfully, after fewer generations once that plan is verified (Table 5). In all three tasks, is the cheapest objective and the most expensive. On stacking and two-nut assembly the MuJoCo rollouts dominate. On PushT, where the simulator is cheap, decoding with the flow does. Per episode, refinement adds about 18.5 s of planning to a stacking episode when episodes run one at a time, and about 36 s when 14 worker processes of 4 threads run episodes in parallel, against 0.1 s for the nominal policy. Decoding the flow on the CPU instead of the GPU roughly doubles the planning time.
Search ablation. Within the 1.5 s budget, the population searches run 40 to 42 generations, or 806 to 841 evaluated plans (Table 16). Of their 1.52 s per chunk, decoding the population with the flow takes 1.45 s and scoring the candidates in the native simulator 0.06 s. Best-of- decodes and scores its single batch of 200 plans in 0.20 s. For the gradient searches, each evaluation is a flow pass at batch size one plus, for every gradient, its vector–Jacobian product. Per chunk, Adam and L-BFGS spend 0.84 and 0.63 s in the flow’s vector–Jacobian product, 0.30 and 0.57 s in its forward pass, and 0.16 and 0.11 s in the model gradient.
Extended Limitations
The task potential. Refinement depends on the task potential. Our potentials are designed by hand from task geometry, with constants calibrated on demonstrations, and they read privileged simulator state. The search optimizes , and the native task outcome improves when follows the task through its intermediate stages, as with the phased potentials of Appendix § 14.§ 6. Future work should replace the hand-designed potential with a learned progress measure that relates to completion and is regular enough for verification. The learned representations and reward models discussed in Appendix § 8 could be starting points.
World model. Refinement rolls out candidates in the simulator that also executes them, so the evaluated rollout matches execution, and it reads the full state of the scene. On a physical system, the rollouts would come from a calibrated simulator or from a learned world model, and the mismatch between predicted and executed motion would enter the convergence result as the endpoint error of Corollary 6. Learned simulators of contact-rich rigid-body dynamics [2] and latent world models [4] (Zhou et al. 2025) are candidates for this role. How model error affects funnel satisfaction is an open question.
Search and guarantees. Refinement reaches useful motions through the prior within a finite search budget and executes its lowest-objective plan together with its estimated-verification status. The convergence results hold under funnel satisfaction of the executed chunks and agreement between simulated rollouts and execution. Two directions would strengthen them: conditions under which a satisfying chunk exists at every planning step, which would give recursive feasibility, and certified bounds on the residual rate, such as the one of Lemma 5, in place of the estimated rates.
Optimization freedom and fidelity to the prior. Any refinement of a generative prior trades optimization freedom against fidelity to the prior. The more the optimizer can change a motion, the lower it can drive the objective and the constraint violation, and the further the motion can move from the demonstrated distribution, where the policy, the tracking controller and the rollouts are less reliable. The radial band is one way to set this tradeoff, through its width . On PushT, the band-constrained search reaches 86.5% success with 11.3% of its motion windows out of distribution, and the unconstrained search reaches 96.0% with 34.1% (Table 2). The band constrains the radius and the mean of the seed and leaves its direction free, so it limits the shift of each chunk. The states that a refined chunk leads to still determine the next observation, which can differ from the demonstrated observations, the covariate shift familiar from imitation learning (Ross et al., 2011). A band width that adapts to the state, wider where the nominal plan is far from satisfying its funnel, is a possible extension.
Computation and deployment. The candidate rollouts within each generation run in parallel, and the generations run in sequence, which gives a planning delay of 0.8 to 8.3 s per chunk in our experiments (Appendix H). Physical deployment would need a scene that stays still during planning, or a prediction of its evolution over the computation interval. Learned rollout models would shorten each generation. The refined seeds could also be amortized into a network that predicts them from the observation, as in learned noise policies for diffusion models [30] (Wagenmaker et al. 2025).
References
- [1]Youhei Akimoto, Yuichi Nagata, Isao Ono, and Shigenobu Kobayashi. Theoretical Foundation for CMA-ES from Information Geometry Perspective. Algorithmica, 64(4):698–716, 2012. doi: 10.1007/s00453-011-9564-8.DOI
- [2]Kelsey R. Allen, Yulia Rubanova, Tatiana Lopez-Guevara, William E. Whitney, Alvaro Sanchez-Gonzalez, Peter Battaglia, and Tobias Pfaff. Learning rigid dynamics with face interaction graph networks. In International Conference on Learning Representations (ICLR), 2023. URL https://openreview.net/forum?id=J7Uh781A05p.arxiv.org/abs/2212.03574
- [3]Anastasios N. Angelopoulos and Stephen Bates. Conformal prediction: A gentle introduction. Foundations and Trends in Machine Learning, 16(4):494–591, 2023. doi: 10.1561/2200000101.DOI
- [4]Mido Assran, Adrien Bardes, David Fan, Quentin Garrido, Russell Howes, Mojtaba Komeili, Matthew Muckley, Ammar Rizvi, Claire Roberts, Koustuv Sinha, Artem Zholus, Sergio Arnaud, Abha Gejji, Ada Martin, Francois Robert Hogan, Daniel Dugas, Piotr Bojanowski, Vasil Khalidov, Patrick Labatut, Francisco Massa, Marc Szafraniec, Kapil Krishnakumar, Yong Li, Xiaodong Ma, Sarath Chandar, Franziska Meier, Yann LeCun, Michael Rabbat, and Nicolas Ballas. V-JEPA 2: Self-supervised video models enable understanding, prediction and planning. arXiv preprint arXiv:2506.09985, 2025.arxiv.org/abs/2506.09985
- [5]Mattijs Baert, Elias Malomgré, Sam Leroux, and Pieter Simoens. Reward Machine Inference for Robotic Manipulation. In Reinforcement Learning Conference (RLC), Workshop on Inductive Biases in Reinforcement Learning, 2025. URL https://openreview.net/forum?id=ItAMw1CMFC.arxiv.org/abs/2412.10096
- [6]Sivakumar Balasubramanian, Alejandro Melendez-Calderon, Agnes Roby-Brami, and Etienne Burdet. On the analysis of movement smoothness. Journal of NeuroEngineering and Rehabilitation, 12(1):112, 2015. doi: 10.1186/s12984-015-0090-9.DOI
- [7]Hadi Beik-Mohammadi, Søren Hauberg, Georgios Arvanitidis, Nadia Figueroa, Gerhard Neumann, and Leonel Rozo. Neural Contractive Dynamical Systems. In International Conference on Learning Representations (ICLR), 2024. URL https://proceedings.iclr.cc/paper_files/paper/2024/hash/d6520fa7f71dc8e09ed5939a60a64218-Abstract-Conference.html.
- [8]Heli Ben-Hamu, Omri Puny, Itai Gat, Brian Karrer, Uriel Singer, and Yaron Lipman. D-Flow: Differentiating through Flows for Controlled Generation. In Proceedings of the 41st International Conference on Machine Learning, volume 235 of Proceedings of Machine Learning Research, pages 3462–3483. PMLR, 2024. URL https://proceedings.mlr.press/v235/ben-hamu24a.html.
- [9]Thomas Berger, Dario Dennstädt, Achim Ilchmann, and Karl Worthmann. Funnel Model Predictive Control for Nonlinear Systems with Relative Degree One. SIAM Journal on Control and Optimization, 60(6):3358–3383, 2022. doi: 10.1137/21M1431655.DOI
- [10]Thomas Berger, Achim Ilchmann, and Eugene P. Ryan. Funnel control – a survey. Annual Reviews in Control, 60:101024, 2025. doi: 10.1016/j.arcontrol.2025.101024.DOI
- [11]Jeff Bezanson, Alan Edelman, Stefan Karpinski, and Viral B Shah. Julia: A fresh approach to numerical computing. SIAM Review, 59(1):65–98, 2017. doi: 10.1137/141000671.DOI
- [12]Mikołaj Bińkowski, Danica J. Sutherland, Michael Arbel, and Arthur Gretton. Demystifying MMD GANs. In International Conference on Learning Representations (ICLR), 2018. URL https://arxiv.org/abs/1801.01401.
- [13]Kevin Black, Noah Brown, Danny Driess, Adnan Esmail, Michael Robert Equi, Chelsea Finn, Niccolo Fusai, Lachy Groom, Karol Hausman, Brian Ichter, Szymon Jakubczak, Tim Jones, Liyiming Ke, Sergey Levine, Adrian Li-Bell, Mohith Muthukuri, Suraj Nair, Karl Pertsch, Lucy Xiaoyang Shi, Laura Smith, James Tanner, Quan Vuong, Anna Walling, Haohuan Wang, and Ury Zhilinsky. π0: A Vision-Language-Action Flow Model for General Robot Control. In Robotics: Science and Systems XXI, Los Angeles, CA, USA, 2025. doi: 10.15607/rss.2025.xxi.010.DOI
- [14]Stephen P. Boyd and Lieven Vandenberghe. Convex Optimization. Cambridge University Press, Cambridge, UK ; New York, 2004. doi: 10.1017/CBO9780511804441.DOI
- [15]Max Braun, Noémie Jacquier, Leonel Rozo, and Tamim Asfour. Riemannian Flow Matching Policy for Robot Motion Learning. In 2024 IEEE/RSJ International Conference on Intelligent Robots and Systems (IROS), pages 5144–5151, 2024. doi: 10.1109/IROS58592.2024.10801521.
- [16]Alberto Camacho, Jacob Varley, Andy Zeng, Deepali Jain, Atil Iscen, and Dmitry Kalashnikov. Reward Machines for Vision-Based Robotic Manipulation. In 2021 IEEE International Conference on Robotics and Automation (ICRA), pages 14284–14290, Xi’an, China, 2021. IEEE. doi: 10.1109/ICRA48506.2021.9561927.
- [17]João Carvalho, An Thai Le, Piotr Kicki, Dorothea Koert, and Jan Peters. Motion Planning Diffusion: Learning and Adapting Robot Motion Planning with Diffusion Models. IEEE Transactions on Robotics, 41:4881–4901, 2025. doi: 10.1109/TRO.2025.3593109.
- [18]Qianzong Chen, Justin Yu, Mac Schwager, Pieter Abbeel, Yide Shentu, and Philipp Wu. SARM: Stage-Aware Reward Modeling for Long Horizon Robot Manipulation. In International Conference on Learning Representations (ICLR), 2026a. URL https://openreview.net/forum?id=aemqAxsCl9.arxiv.org/abs/2509.25358
- [20]Ricky T. Q. Chen and Yaron Lipman. Flow Matching on General Geometries. In International Conference on Learning Representations (ICLR), 2024. URL https://openreview.net/forum?id=g7ohD1TITL.arxiv.org/abs/2302.03660
- [21]Cheng Chi, Zhenjia Xu, Siyuan Feng, Eric Cousineau, Yilun Du, Benjamin Burchfiel, Russ Tedrake, and Shuran Song. Diffusion policy: Visuomotor policy learning via action diffusion. The International Journal of Robotics Research, 44(10–11):1684–1704, 2025. doi: 10.1177/02783649241273668.DOI
- [22]Gregory S. Chirikjian. Stochastic Models, Information Theory, and Lie Groups, Volume 2: Analytic Methods and Modern Applications. Applied and Numerical Harmonic Analysis. Birkhäuser Boston, Boston, 2012. doi: 10.1007/978-0-8176-4944-9.DOI
- [23]Eugenio Chisari, Nick Heppert, Max Argus, Tim Welschehold, Thomas Brox, and Abhinav Valada. Learning Robotic Manipulation Policies from Point Clouds with Conditional Flow Matching. In Proceedings of The 8th Conference on Robot Learning, volume 270 of Proceedings of Machine Learning Research, pages 982–993. PMLR, 2025. URL https://proceedings.mlr.press/v270/chisari25a.html.arxiv.org/abs/2409.07343
- [24]Jacob K. Christopher, Stephen Baek, and Ferdinando Fioretto. Constrained synthesis with projected diffusion models. In Advances in Neural Information Processing Systems, volume 37, pages 89307–89333, 2024. doi: 10.52202/079017-2834. URL https://proceedings.neurips.cc/paper_files/paper/2024/hash/a28faf2f2f70be183afc16797a56b91-Abstract-Conference.html.DOI
- [25]S. Colutto, F. Fruhauf, M. Fuchs, and O. Scherzer. The CMA-ES on Riemannian Manifolds to Reconstruct Shapes in 3-D Voxel Images. IEEE Transactions on Evolutionary Computation, 14(2):227–245, 2010. doi: 10.1109/TEVC.2009.2029567.DOI
- [26]Alexandre Didier, Andrea Zanelli, Kim P. Wabersich, and Melanie N. Zeilinger. Predictive stability filters for nonlinear dynamical systems affected by disturbances. IFAC-PapersOnLine, 58(18):200–207, 2024. doi: 10.1016/j.ifacol.2024.09.031.DOI
- [27]Haoran Ding, Noémie Jaquier, Jan Peters, and Leonel Rozo. Fast and Robust Visuomotor Riemannian Flow Matching Policy. IEEE Transactions on Robotics, 41:5327–5343, 2025. doi: 10.1109/TRO.2025.3601293.
- [28]Maximilian Du and Shuran Song. DynaGuide: Steering Diffusion Policies with Active Dynamic Guidance. In Advances in Neural Information Processing Systems, volume 38, pages 49413–49442, 2025. doi: 10.52202/085713-1473.DOI
- [29]Frederik Ebert, Chelsea Finn, Sudeep Dasari, Annie Xie, Alex Lee, and Sergey Levine. Visual foresight: Model-based deep reinforcement learning for vision-based robotic control. arXiv preprint arXiv:1812.00568, 2018.arxiv.org/abs/1812.00568
- [30]Luca Eyring, Shyamgopal Karthik, Alexey Dosovitskiy, Natianel Ruiz, and Zeynep Akata. Noise hypernetworks: Amortizing test-time compute in diffusion models. In Advances in Neural Information Processing Systems, volume 38, 2025. doi: 10.52202/085713-3190.DOI
- [31]Georgios E. Fainekos and George J. Pappas. Robustness of temporal logic specifications for continuous-time signals. Theoretical Computer Science, 410(42):4262–4291, 2009. doi: 10.1016/j.tcs.2009.06.021.DOI
- [32]Ruiqi Feng, Chenglei Yu, Wenhao Deng, Peiyan Hu, and Tailin Wu. On the guidance of flow matching. In Proceedings of the 42nd International Conference on Machine Learning, volume 267 of Proceedings of Machine Learning Research, pages 16993–17029. PMLR, 2025. URL https://proceedings.mlr.press/v267/feng25s.html.arxiv.org/abs/2502.02150
- [33]Ruben Grandia, Andrew Taylor, Andrew Singletary, Marco Hutter, and Aaron Ames. Nonlinear Model Predictive Control of Robotic Systems with Control Lyapunov Functions. In Robotics: Science and Systems XVI. Robotics: Science and Systems Foundation, 2020. doi: 10.15607/RSS.2020.XVI.098.DOI
- [34]Chandon Hamel. FlowMPC: Improving Flow Matching policies with World Models. arXiv preprint arXiv:2606.16286, June 2026.arxiv.org/abs/2606.16286
- [35]Nikolaus Hansen. The CMA Evolution Strategy: A Tutorial. arXiv preprint arXiv:1604.00772, March 2023.
- [36]Richard Hartley, Jochen Trumpf, Yuchao Dai, and Hongdong Li. Rotation Averaging. International Journal of Computer Vision, 103(3):267–305, 2013. doi: 10.1007/s11263-012-0601-0.DOI
- [37]Shashank Hegde, Alexander Popov, Elie Aljalbout, and Nikolai Smolyansky. Diffusion-Steering-Based MPC with a JEPA World Action Model. arXiv preprint arXiv:2610.12407, October 2026.arxiv.org/abs/2610.12407
- [38]Achim Ilchmann, E. P. Ryan, and C. J. Sangwin. Tracking with prescribed transient behaviour. ESAIM: Control, Optimisation and Calculus of Variations, 7:471–493, 2002. doi: 10.1051/cocv:2002064.DOI
- [39]Korrawe Karunratanakul, Konpat Preechakul, Emre Aksan, Thabo Beeler, Supasorn Suwajanakorn, and Siyu Tang. Optimizing diffusion noise can serve as universal motion priors. In 2024 IEEE/CVF Conference on Computer Vision and Pattern Recognition (CVPR), pages 1334–1345, 2024. doi: 10.1109/CVPR52733.2024.00133.DOI
- [40]Roger Koenker and Gilbert Bassett, Jr. Regression Quantiles. Econometrica, 46(1):33–50, 1978. doi: 10.2307/1913643.DOI
- [41]Tony Lee, Andrew Wagenmaker, Karl Pertsch, Percy Liang, Sergey Levine, and Chelsea Finn. RoboReward: General-purpose vision-language reward models for robotics. arXiv preprint arXiv:2601.00675, 2026.arxiv.org/abs/2601.00675
- [42]Scott Lembcke. Chipmunk2D: A fast and lightweight 2D physics library. https://codeberg.org/slembcke/Chipmunk2D, 2015.






