betaFeedback

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

  1. 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.

  2. 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.

  3. 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.

  4. 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

min⁡z0sup⁡t∈[0,H][V(T(xwk(t)))−ρk(t)]s.t.w=ψθ(1∣z0,ok)u(t)=κ(xwk(t),w,t)x˙wk(t)=f(xwk(t),u(t)),xwk(0)=xk(1)\begin{aligned} \min_{z_0}\quad&\sup_{t\in[0,H]}\left[V\left(T\left(x_w^k(t)\right)\right)-\rho_k(t)\right] \\ \text{s.t.}\quad&w=\psi_\theta(1\mid z_0,o_k) \\ &u(t)=\kappa\left(x_w^k(t),w,t\right) \\ &\dot{x}_w^k(t)=f\left(x_w^k(t),u(t)\right),\quad x_w^k(0)=x_k \tag*{(1)} \end{aligned}
Whole-horizon task residual, flow prior, tracking controller, and world dynamics

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 kk, 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 VV 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 oko_k, the learned flow map ψθ\psi_\theta transports a random seed z0z_0 into a waypoint action chunk w=ψθ(1∣z0,ok)w = \psi_\theta(1 \mid z_0, o_k). Refinement searches over the seed while leaving this map fixed. A low-level controller κ\kappa tracks the chunk’s waypoints and produces the applied input u(t)u(t), e.g. motor torques. In (1), xwk(t)x_w^k(t) is the world trajectory from the current state xkx_k, TT extracts its task state, VV measures task error, and ρk\rho_k is the envelope over the horizon [0,H][0,H]. 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 x(t)x(t) denote the state of the robot and its environment, u(t)u(t) the applied input, and ww a waypoint action chunk, which the controller κ\kappa tracks according to its execution timing. Under the controlled dynamics of (1), at iteration kk the plan induces a rollout xwk(t)=Rκ(xk,w;t)x_w^k(t) = \mathcal{R}_\kappa(x_k,w;t) from the current world state over t∈[0,H]t \in[0,H], 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 y=T(x)∈Yy = T(x) \in\mathcal{Y} and a goal set G⊆Y\mathcal{G} \subseteq\mathcal{Y}.1 The task rollout is ywk(t)=T(xwk(t))y_w^k(t) = T(x_w^k(t)). Progress is measured by a task-level Lyapunov candidate V:Y→R≥0V:\mathcal{Y} \to\mathbb{R}_{\geq0}, which we call the task potential, with goal set G={y:V(y)≤vgoal}\mathcal{G} = \{y : V(y) \leq v_{\mathrm{goal}}\}, vgoal≥0v_{\mathrm{goal}} \geq0. An exact goal has vgoal=0v_{\mathrm{goal}} = 0, with VV positive outside G\mathcal{G}, 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 VV 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 ρk:[0,H]→R≥0\rho_k : [0,H] \to\mathbb{R}_{\geq0}. Starting from the current value Vk=V(yk)V_k = V(y_k), this envelope allows temporary increases while requiring a smaller terminal value, so that those maneuvers produce net progress:

ρk(0)=Vk,initial anchoring,sup⁡t∈[0,H]ρk(t)≤(1+dk)Vk,bounded transient regression,ρk(H)≤(1−γk)Vk,terminal contraction.(2)\begin{aligned} \rho_k(0) &= V_k, && \text{initial anchoring},\\ \sup_{t\in[0,H]} \rho_k(t) &\leq(1+d_k)V_k, && \text{bounded transient regression},\\ \rho_k(H) &\leq(1-\gamma_k)V_k, && \text{terminal contraction}. \tag*{(2)} \end{aligned}

with γk∈[0,1]\gamma_k \in[0,1] and dk≥0d_k \geq0. We ask the candidate motion to remain within this envelope throughout execution:

V(ywk(t))≤ρk(t)for every t∈[0,H].(3)V(y_w^k(t)) \leq\rho_k(t) \qquad\text{for every } t \in[0,H]. \tag*{(3)}

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 wk∗w_k^* satisfies its funnel (3) with an envelope obeying (2), is executed over the full horizon H>0H > 0 before replanning, and has an evaluated task rollout that matches execution. If the terminal contraction is uniformly positive, γk≥γ‾>0\gamma_k \ge\overline{\gamma} > 0, and the relative transient allowance is uniformly bounded, dk≤d‾<∞d_k \le\overline{d} < \infty, then

sup⁡t∈[0,H]V(ywk∗k(t))≤(1+d‾)(1−γ‾)kV(y0).(4)\sup_{t\in[0,H]} V(y_{w_k^*}^k(t)) \le(1+\overline{d})(1-\overline{\gamma})^k V(y_0). \tag*{(4)}

Task error therefore converges to zero throughout execution. For vgoal>0v_{\mathrm{goal}} > 0, execution enters G\mathcal{G} 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,

gk(w,t)=V(ywk(t))−ρk(t),Sk(w)=sup⁡t∈[0,H]gk(w,t),(5)g_k(w,t) = V(y_w^k(t))-\rho_k(t), \qquad S_k(w)=\sup_{t\in[0,H]} g_k(w,t), \tag*{(5)}

so that the funnel holds over the whole horizon exactly when Sk(w)≤0S_k(w)\le0. Simulating Rκ\mathcal{R}_\kappa gives the residual at instants 0=t1<⋯<tn=H0=t_1<\cdots<t_n=H, with spacings Δi=ti+1−ti\Delta_i=t_{i+1}-t_i, samples gi=gk(w,ti)g_i=g_k(w,t_i), and largest sampled value Mk(w)=max⁡igiM_k(w)=\max_i g_i. Requiring Mk(w)≤0M_k(w)\le0, 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 kk and a plan ww, and suppose that gk(w,⋅)g_k(w,\cdot) is LiL_i-Lipschitz on each interval [ti,ti+1][t_i,t_{i+1}]. Then,

Sk(w)≤Bk(w)=max⁡1≤i<ngi+gi+1+LiΔi2.(6)S_k(w) \le B_k(w) = \max_{1\le i<n} \frac{g_i+g_{i+1}+L_i\Delta_i}{2}. \tag*{(6)}

Consequently,

Bk(w)≤0⟹V(ywk(t))≤ρk(t)∀t∈[0,H].(7)B_k(w)\le0 \quad\Longrightarrow\quad V(y_w^k(t))\le\rho_k(t)\quad\forall t\in[0,H]. \tag*{(7)}

On each interval, the residual lies below the two lines of slope LiL_i through its samples, and these lines meet at the value in (6) (proof in Appendix § 13.§ 3). Appendix § 13.§ 2 bounds the rates LiL_i 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 L^i\widehat{L}_i 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 D={(oi,wi)}\mathcal{D} = \{(o_i, w_i)\} of observation histories and action chunks, a conditional flow-matching policy learns a vector field vθ(z,τ∣o)v_\theta(z, \tau\mid o) (Lipman et al., 2023, 2024). Integrating dψθ/dτ=vθ(ψθ,τ∣o)\mathrm{d}\psi_\theta/\mathrm{d}\tau= v_\theta(\psi_\theta, \tau\mid o) from a source seed, ψθ(0∣z0,o)=z0\psi_\theta(0 \mid z_0, o) = z_0, to τ=1\tau= 1 decodes the seed into an action chunk w=ψθ(1∣z0,o)w = \psi_\theta(1 \mid z_0, o). Generative time τ\tau parameterizes the construction of the entire chunk, and physical time tt 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

Jk(w)=β−1log⁡∑i=1neβgi.(8)J_k(w) = \beta^{-1} \log\sum_{i=1}^{n} e^{\beta g_i}. \tag*{(8)}

It accounts for the worst residual and for the values close to it, and the temperature β>0\beta> 0 controls how closely it approximates the largest sampled residual MkM_k [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-JkJ_k 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 a∈Rda \in\mathbb{R}^{d}, the projection onto the centered band is

Ψ(a)=(a−aˉ1)clip⁡(∥a−aˉ1∥,rlo,rhi)∥a−aˉ1∥,aˉ=d−1∑j=1daj,(9)\Psi(a) = (a - \bar{a}\mathbf{1}) \frac{\operatorname{clip}(\lVert a - \bar{a}\mathbf{1}\rVert, r_{\mathrm{lo}}, r_{\mathrm{hi}})}{\lVert a - \bar{a}\mathbf{1}\rVert}, \qquad\bar{a} = d^{-1}\sum_{j=1}^{d} a_j, \tag*{(9)}

which shifts the entries to zero mean and clips the radius. The radii rlor_{\mathrm{lo}} and rhir_{\mathrm{hi}} are the quantiles of the source radius at tail probabilities Φ(−ζ)\Phi(-\zeta) and Φ(ζ)\Phi(\zeta), with Φ\Phi 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 aℓ∼N(m,σ2C)a_\ell\sim\mathcal{N}(m, \sigma^2 C), ℓ=1,…,λ\ell= 1,\ldots,\lambda, and ranks the samples by Fk(a)=Jk(ψθ(1∣C(Ψ(a)),ok))F_k(a) = J_k(\psi_\theta(1 \mid C(\Psi(a)), o_k)). The seed chart CC maps the coordinates to a seed z0z_0 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 N(0,Id)\mathcal{N}(0, I_d) (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, m←Ψ(m)m \leftarrow\Psi(m), after each update.

Algorithm 1: Task-funnel refinement of generative action chunks

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 VV, 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 r∈[0,1]r \in[0,1], where higher is better, and its success predicate. On PushT, rr is the coverage of the goal by the block, with success at r>0.95r > 0.95. Coverage changes continuously with the motion of the block, so the score registers progress within a chunk. On stacking, r=12aRG(1+aBR)r = \frac{1}{2}a_{RG}(1 + a_{BR}), where aXYa_{XY} 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 VV at the end of the chunk, as progress- and goal-based objectives do [37] (Yan et al. 2026). V˙≤0\dot{V} \le0 asks VV to decrease throughout the chunk, as stepwise Lyapunov conditions do (Mizuta and Leung, 2024; Pérez-Dattari et al., 2026). ΣV\Sigma V sums VV over the chunk, as a model-predictive cost does [34]. The plateau funnel bounds the interior uniformly by (1+δ)Vk(1+\delta)V_k, and the linear funnel prescribes steady progress. The remaining funnels are fitted to demonstrated traces of VV and share one shape, which descends to (1−γk)Vk(1-\gamma_k)V_k 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 VV (additive) or as fractions of VkV_k (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 VV to rise further within the chunk. The leniency α\alpha of a learned funnel is a quantile level: given the observation, a fraction α\alpha of the demonstrated chunks reaches the requested progress and a fraction α\alpha stays within the allowance, so a larger α\alpha 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 CVaR10\mathrm{CVaR}_{10} 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 max⁡t(max⁡s≤trs−rt)\max_t(\max_{s\le t} r_s-r_t), the largest fall of the score below its running maximum, in points (×100\times100), through its mean and its CVaR90\mathrm{CVaR}_{90}, 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).

PushT drawdown exceedance curves
ObjectiveSuccessFinal scoreMax drawdown [pts] ↓Verified
PushT [%] ↑Stack. [%] ↑PushT CVaR10_{10} ↑Stack. CVaR10_{10} ↑PushT MeanStack MeanPushT CVaR90_{90}Stack CVaR90_{90}
Nominal31.377.0.000.00040.08.586.946.1
Endpoint-only86.886.0.560.08428.36.862.846.1
V˙≤0\dot{V} \le060.585.5.218.10323.45.854.241.8
∑V\sum V80.082.0.499.00022.66.454.443.4
Plateau δ=0.5\delta= 0.573.083.8.494.07523.96.956.746.2
Linear54.578.8.194.00024.37.654.744.3
Calibrated global88.580.5.587.00127.47.562.946.2
Learn. add. α=0.5\alpha= 0.584.885.0.613.16222.97.652.347.0
Learn. mult. α=0.95\alpha= 0.9563.884.0.424.10723.55.754.040.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 VV rises within the chunk. Funnels with a transient allowance accommodate this rise, and the objectives that ask VV to fall throughout the chunk, V˙≤0\dot{V} \le0 and the linear funnel, reach 54.5% to 60.5% success. On stacking, VV 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 α=0.5\alpha= 0.5 retains the most, lowering the drawdown CVaR90_{90} from 62.8 to 52.3 at a success statistically on par with endpoint-only. On stacking, the learned multiplicative funnel at α=0.95\alpha= 0.95 significantly lowers the drawdown CVaR90_{90}, 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 V(t)V(t), 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 δ=1\delta= 1 as the shared objective. Ours is CMA-ES on the band of (9) at ζ=4\zeta= 4, the setting of every other experiment. CMA-ES without the band isolates the role of the band. Best-of-NN 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-NN 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-NN. The success differences from best-of-NN 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.

SearchSucc.↑CVaR10_{10} ↑LDJ↑OOD%↓
L-BFGS†70.0.765−10.1512.0
Best-of-NN82.5.768−9.874.9
CEM79.0.848−10.288.0
CMA-ES, no band96.0.941−10.9634.1
Ours, ζ=4\zeta=486.5.877−9.9311.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 VV, 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 ψθ\psi_\theta of the learned vector field vθ(z,τ∣o)v_\theta(z,\tau\mid o) transports a source distribution p0p_0 to the conditional data distribution, (ψθ(1∣⋅,o))#p0≈pdata(⋅∣o)(\psi_\theta(1 \mid\cdot,o))_\#p_0 \approx p_{\mathrm{data}}(\cdot\mid o), where the pushforward f#pf_\#p denotes the distribution of f(z)f(z) for z∼pz \sim p (Lipman et al., 2023, 2024). For Euclidean actions, vθv_\theta regresses the velocity of the path zτ=(1−τ)z0+τwz_\tau=(1-\tau)z_0+\tau w, with loss E∥vθ(zτ,τ∣o)−(w−z0)∥22\mathbb{E}\lVert v_\theta(z_\tau,\tau\mid o)-(w-z_0)\rVert_2^2 over (o,w)∼D(o,w)\sim\mathcal{D}, z0∼p0z_0\sim p_0 and τ∼U[0,1]\tau\sim\mathcal{U}[0,1]. For pose-valued actions we use RMFM [20, 15] with the data-centered wrapped-normal rotational source described below. In both cases a seed z0z_0 is decoded into an action chunk by integrating dψθ/dτ=vθ(ψθ,τ∣o)d\psi_\theta/d\tau=v_\theta(\psi_\theta,\tau\mid o) from ψθ(0∣z0,o)=z0\psi_\theta(0\mid z_0,o)=z_0 to τ=1\tau=1.

Pose notation. We use standard Lie-group notation for SO(3)\mathrm{SO}(3) and SE(3)\mathrm{SE}(3): exponential and logarithm maps, and the hat and vee operators identifying a body twist ξ∈R6\xi\in\mathbb{R}^{6} with its Lie-algebra matrix ξ^\hat{\xi} (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 SE(3)×R\mathrm{SE}(3)\times\mathbb{R}, 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 (v,ω)(v,\omega) 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 G∈SE(3)G \in\mathrm{SE}(3) for the pose and r∈Rr \in\mathbb{R} for the gripper variable. For source and target poses, let ξ=log⁡(G0−1G1)∨\xi= \log(G_0^{-1}G_1)^\vee. The training path is

Gτ=G0exp⁡(τξ^),rτ=(1−τ)r0+τr1,(10)G_\tau= G_0 \exp(\tau\hat{\xi}), \qquad r_\tau= (1-\tau)r_0+\tau r_1, \tag*{(10)}

a screw motion with constant body velocity ξ\xi, which couples translation and rotation through the SE(3)\mathrm{SE}(3) exponential, while the gripper moves at constant rate r1−r0r_1-r_0. Applied waypoint-wise, this gives the flow-matching target ([15, 20]). Sampling uses 10 Lie–Euler steps,

G←Gexp⁡(Δτ v^θpose),r←r+Δτ vθgrip,(11)G \leftarrow G\exp\left(\Delta\tau\,\hat{v}_{\theta}^{\mathrm{pose}}\right), \qquad r \leftarrow r+\Delta\tau\,v_{\theta}^{\mathrm{grip}}, \tag*{(11)}

so the rotation stays on SO(3)\mathrm{SO}(3) 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,

R0=Rˉexp⁡(σrot[ϵR]×),ϵR∼N(0,I3),σrot=0.5 rad,(12)R_0 = \bar{R}\exp\left(\sigma_{\mathrm{rot}}[\epsilon_R]_\times\right), \qquad\epsilon_R \sim\mathcal{N}(0,I_3), \qquad\sigma_{\mathrm{rot}}=0.5\ \mathrm{rad}, \tag*{(12)}

which is then converted to the 13-dimensional carrier. Here [⋅]×[\cdot]_\times is the skew-symmetric matrix representation. The center Rˉ\bar{R} is computed from demonstration rotations: its unit quaternion is a dominant eigenvector of ∑jqjqjT\sum_j q_jq_j^\mathsf{T}, 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 π\pi 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 SE(3)\mathrm{SE}(3) exponential. The map ϵR↦R0\epsilon_R \mapsto R_0 is injective for rotation angles below π\pi, where the principal logarithm recovers ϵR\epsilon_R (Hartley et al. [36]).

Task Progress Measures and Task Potentials

This appendix constructs the task potential VV of § 3, a task-level Lyapunov candidate, so that VV 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 VV constant, contacts that push, drop or topple objects, and detours away from the goal, so VV remains a candidate, and the funnel imposes its decrease on each executed chunk. All constructions are stated on a bounded operating domain Ω\Omega 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 Ω\Omega.

  • Zero set. VV is nonnegative and vanishes exactly on the completed task, so that the terminal contraction of Theorem 1 drives execution toward completion.

  • Regularity. VV is Lipschitz along rollouts, as the verification bound requires (Lemma 5). We construct it C1C^{1}, which gives a Lipschitz constant on the bounded domain Ω\Omega and keeps kinks out of the trace that the funnel evaluates.

  • No ridges. A motion that advances the current subtask never increases VV, so the funnel does not penalize progress on that subtask.

  • Ordering. Completing a subtask never increases VV, and VV 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 ϕ\phi 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 ξ\xi that describe the prerequisite and completion of a subtask, and define nonnegative costs U0(ξ)U_0(\xi) and Q(ξ)Q(\xi) 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 ϕ(ξ)\phi(\xi) defined above. It should vanish at the intended geometric goal and decrease along the intermediate motions that lead to it. In stacking, ξ=(d,e)\xi=(d,e) collects the horizontal distance and the vertical gap between a cube and its support, U0U_0 is smallest when the cube is carried at a clearance above its support, and QQ when it is centred over the support and lowered onto it (Appendix § 10.§ 5).

Connecting regimes smoothly. With an offset Dˉ≥0\bar{D} \ge0, let U(ξ)=U0(ξ)+DˉU(\xi) = U_0(\xi) + \bar{D}, and blend the two regimes through a gate ℓ(ξ)∈[0,1]\ell(\xi) \in[0,1],

ϕ(ξ)=[1−ℓ(ξ)]U(ξ)+ℓ(ξ)Q(ξ).(13)\phi(\xi) = [1-\ell(\xi)]U(\xi) + \ell(\xi)Q(\xi). \tag*{(13)}

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 C1C^1 with zero slope at both ends of the transition, so that the blend has no kinks. The blend is then nonnegative, and if U>0U > 0 and QQ vanishes exactly at the goal, where ℓ=1\ell= 1, ϕ\phi has the desired zero set. When a scalar coordinate a(ξ)a(\xi) increases with prerequisite progress, the clamped cubic step is the lowest-degree polynomial with these properties,

ℓ=s(a−aloahi−alo),s(u)={0,u≤0,3u2−2u3,0<u<1,1,u≥1,(14)\ell= s\left(\frac{a-a_{\mathrm{lo}}}{a_{\mathrm{hi}}-a_{\mathrm{lo}}}\right), \qquad s(u) = \begin{cases} 0, & u \le0,\\ 3u^2 - 2u^3, & 0 < u < 1,\\ 1, & u \ge1, \end{cases} \tag*{(14)}

where [alo,ahi][a_{\mathrm{lo}},a_{\mathrm{hi}}] 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 ϕ\phi. For a coordinate ξa\xi_a that increases with the desired prerequisite motion,

∂ξaϕ=(1−ℓ)∂ξaU+ℓ∂ξaQ+(∂ξaℓ)(Q−U).(15)\partial_{\xi_a}\phi= (1-\ell)\partial_{\xi_a}U + \ell\partial_{\xi_a}Q + (\partial_{\xi_a}\ell)(Q-U). \tag*{(15)}

Suppose that both regime costs decrease along this motion, ∂ξaU0≤0\partial_{\xi_a}U_0 \le0 and ∂ξaQ≤0\partial_{\xi_a}Q \le0, and that the gate rises along it, ∂ξaℓ≥0\partial_{\xi_a}\ell\ge0, on the transition band Ωtr⊆Ω\Omega_{\mathrm{tr}} \subseteq\Omega where 0<ℓ<10 < \ell< 1. The first two terms are then nonpositive, and the last one is nonpositive whenever Q≤UQ \le U. A sufficient offset is therefore

Dˉ≥max⁡{0,sup⁡ξ∈Ωtr[Q(ξ)−U0(ξ)]},(16)\bar{D} \ge\max\left\{0,\sup_{\xi\in\Omega_{\mathrm{tr}}}[Q(\xi)-U_0(\xi)]\right\}, \tag*{(16)}

which gives ∂ξaϕ≤0\partial_{\xi_a}\phi\le0 on the band, the no-ridge requirement. The offset is computed once from Ω\Omega and involves no tuning on trajectories.

Composing Subtasks

For two successive subtasks with residuals ϕ1\phi_1 and ϕ2\phi_2, choose a C1C^1 completion gate χ:[0,∞)→[0,1]\chi: [0,\infty) \to[0,1] with χ′≤0\chi' \le0 and χ(0)=1\chi(0) = 1, which exposes the second residual as the first subtask is completed. Choose a reserve Bˉ≥sup⁡y∈Ωϕ2(y)\bar{B} \ge\sup_{y \in\Omega}\phi_2(y) and define

V(y)=ϕ1(y)+[1−χ(ϕ1g(y))]Bˉ+χ(ϕ1g(y))ϕ2(y).(17)V(y) = \phi_1(y) + [1-\chi(\phi_1^g(y))]\bar{B} + \chi(\phi_1^g(y))\phi_2(y). \tag*{(17)}

While the first subtask is incomplete, χ=0\chi= 0 and the second subtask enters only through the constant Bˉ\bar{B}, so VV does not depend on ϕ2\phi_2: in stacking, moving the blue cube before the red one is placed leaves VV unchanged, so VV decreases only through the current subtask. As the first subtask is completed, Bˉ\bar{B} is exchanged for the actual second residual, which is no larger on Ω\Omega, so the exchange cannot itself increase VV.

The gate reads a gate residual ϕ1g\phi_1^{g}: a nonnegative C1C^1 residual of the first subtask that vanishes on the same set as ϕ1\phi_1. The simplest choice is ϕ1g=ϕ1\phi_1^{g}=\phi_1. A separate gate residual is useful when ϕ1\phi_1 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

χ(ϕ)=s(bhi−ϕbhi−blo),0<blo<bhi,(18)\chi(\phi)=s\left(\frac{b_{\mathrm{hi}}-\phi}{b_{\mathrm{hi}}-b_{\mathrm{lo}}}\right), \qquad0<b_{\mathrm{lo}}<b_{\mathrm{hi}}, \tag*{(18)}

with χ=1\chi=1 for ϕ≤blo\phi\le b_{\mathrm{lo}} and χ=0\chi=0 for ϕ≥bhi\phi\ge b_{\mathrm{hi}}: [blo,bhi][b_{\mathrm{lo}},b_{\mathrm{hi}}] is the band of first-stage gate residual over which the second subtask is activated.

Proposition 3 (Smooth sequential composition) Let ϕ1\phi_1, ϕ2\phi_2, and ϕ1g\phi_1^{g} be nonnegative C1C^1 residuals with {ϕ1=0}={ϕ1g=0}\{\phi_1=0\}=\{\phi_1^{g}=0\}, and let χ\chi and Bˉ\bar{B} be as above. Then VV is nonnegative and C1C^1 on Ω\Omega, with V(y)=0V(y)=0 exactly when ϕ1(y)=ϕ2(y)=0\phi_1(y)=\phi_2(y)=0. In residual coordinates,

∂V∂ϕ1=1,∂V∂ϕ1g=χ′(ϕ1g)(ϕ2−Bˉ)≥0,∂V∂ϕ2=χ(ϕ1g)∈[0,1].(19)\frac{\partial V}{\partial\phi_1}=1,\qquad\frac{\partial V}{\partial\phi_1^{g}}=\chi'(\phi_1^{g})(\phi_2-\bar{B})\ge0,\qquad\frac{\partial V}{\partial\phi_2}=\chi(\phi_1^{g})\in[0,1]. \tag*{(19)}

Proof. Every term in (17) is nonnegative. If V=0V=0, then ϕ1=0\phi_1=0, hence ϕ1g=0\phi_1^{g}=0, χ=1\chi=1, and ϕ2=0\phi_2=0; the converse follows by substitution. Products and compositions preserve C1C^1 regularity. Differentiation gives (19), whose signs follow from χ′≤0\chi'\le0 and ϕ2≤Bˉ\phi_2\le\bar{B}. ■

Reducing either first-stage residual at a fixed second residual therefore never increases VV, including during activation, and the first subtask has full weight while the second has weight χ≤1\chi\le1. Together with the zero set and the C1C^1 regularity of the proposition, this meets the ordering requirement. Along a trajectory, all residuals change together,

V˙=ϕ˙1+χ′(ϕ1g)(ϕ2−Bˉ)ϕ˙1g+χ(ϕ1g)ϕ˙2,\dot{V}=\dot{\phi}_1+\chi'(\phi_1^{g})(\phi_2-\bar{B})\dot{\phi}_1^{g}+\chi(\phi_1^{g})\dot{\phi}_2,

so the construction does not fix the sign of V˙\dot{V}, and the funnel evaluates how VV 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).

SymbolMeaningR on GB on RRule
Geometry and physical tolerances
hX,hYh_X, h_Yhalf-heights0.020/0.0250.020/0.020model geometry
τxy=τz\tau_{xy} = \tau_zerror scales0.0250.020hYh_Y
λz\lambda_zvertical weight11design
dlo/dhid_{\mathrm{lo}}/d_{\mathrm{hi}}lowering band0.010/0.0450.010/0.040dlod_{\mathrm{lo}} design; dhi=hX+hYd_{\mathrm{hi}} = h_X + h_Y
cccarry clearance0.0500.0502hX+0.012h_X + 0.01
alo/ahia_{\mathrm{lo}}/a_{\mathrm{hi}}lift band−0.027/−0.012-0.027/-0.012−0.027/−0.012-0.027/-0.012≤12\le12 mm above support, 15 mm band
λpre\lambda_{\mathrm{pre}}pre-positioning0.010.01design
λalign\lambda_{\mathrm{align}}alignment1010above jitter, below a stage drop
ϕRGg\phi^{g}_{RG} bandsgate residualdlo=0.025d_{\mathrm{lo}} = 0.025, alo/ahi=−0.045/−0.030a_{\mathrm{lo}}/a_{\mathrm{hi}} = -0.045/-0.030wider, no alignment basin
Analytic composition constants (on Ω\Omega)
Dˉ\bar{D}lift offset559.65868.83(24)
Dˉg\bar{D}^{g}gate-residual offset549.65(24), λalign=0\lambda_{\mathrm{align}} = 0
Bˉ\bar{B}second-stage reserve1139.36≥sup⁡ΩϕBR\ge\sup_{\Omega}\phi_{BR}
δz\delta_zno-ridge margin0.0045lowering-band condition
Demonstration-informed
Ω\Omegaoperating domainpX,xy∈[−0.2,0.2]2p_{X,xy} \in[-0.2, 0.2]^2 at reset; d≤0.59d \le0.59MimicGen reset range + margin
σalign\sigma_{\mathrm{align}}alignment scale0.0100.010typical demo seat offset
blo/bhib_{\mathrm{lo}}/b_{\mathrm{hi}}completion-gate band1.093/2.1861.1×1.1\times largest completed; bhi=2blob_{\mathrm{hi}} = 2b_{\mathrm{lo}}

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.

SymbolMeaningSquareRoundRule
τr\tau_rlateral tolerance0.030.03half-width of the native success box
zseat/zappz_{\mathrm{seat}}/z_{\mathrm{app}}seated / approach height0.83/0.970.83/0.97model geometry; peg top plus nut thickness
qloq_{\mathrm{lo}}aligned threshold0.1010.163(seated offset/τr\tau_r)2^2
λtilt\lambda_{\mathrm{tilt}}tilt weight5.133.111/sin⁡21/\sin^2 of the threading tilt limit
λyaw\lambda_{\mathrm{yaw}}yaw weight0.01270(clearance/τr\tau_r)2/4^2/4; none for the round nut
qhiq_{\mathrm{hi}}valve closure11edge of the native box
Hˉ\bar{H}height reserve5.045.04λz/s(τz/(zapp−zseat))\lambda_z/s(\tau_z/(z_{\mathrm{app}}-z_{\mathrm{seat}})), τz=0.04\tau_z=0.04, λz=1\lambda_z=1
Llift=δrestL_{\mathrm{lift}}=\delta_{\mathrm{rest}}lift credit, corner width5.045.04Hˉ\bar{H}
hlifth_{\mathrm{lift}}lift band0.020.02τz/2\tau_z/2
Analytic composition constants (on Ω\Omega)
Bˉ\bar{B}second-stage reserve46.9≥sup⁡Ωϕrd\ge\sup_{\Omega}\phi_{\mathrm{rd}}
Demonstration-informed
zliftz_{\mathrm{lift}}lift height0.890.89highest spawn height of the reset
qrestq_{\mathrm{rest}}alignment bound on Ω\Omega28.3536.781.1×\times largest observed
blo/bhib_{\mathrm{lo}}/b_{\mathrm{hi}}completion-gate band0.136/0.2711.1×\times largest ϕsq\phi_{\mathrm{sq}} over flat final seats; bhi=2blob_{\mathrm{hi}}=2b_{\mathrm{lo}}

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 Ω\Omega. The lift offset Dˉ\bar{D} is the bound (16) evaluated on Ω\Omega. The stage reserve Bˉ\bar{B} is the largest value of the second-stage residual on Ω\Omega, which keeps VV from rising at the hand-over in (17). The composition properties hold on Ω\Omega, 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 pTp_T, target position pGp_G, and orientations θT\theta_T, θG\theta_G, use

VPushT(y)=∥pT−pG∥22+λθwrap⁡(θT−θG)2,(20)V_{\mathrm{PushT}}(y)=\lVert p_T-p_G\rVert_2^2+\lambda_\theta\operatorname{wrap}(\theta_T-\theta_G)^2, \tag*{(20)}

where wrap⁡(u)=atan2⁡(sin⁡u,cos⁡u)∈(−π,π]\operatorname{wrap}(u)=\operatorname{atan2}(\sin u,\cos u)\in(-\pi,\pi], positions are in the pixel units of the 512×512512 \times512 workspace, angles are in radians, and λθ=104\lambda_\theta=10^4, so that an angular error of 0.10.1 rad weighs as much as a position error of 10 pixels. For λθ>0\lambda_\theta>0, 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 RR on the green cube GG and then the blue cube BB on the red one. Each placement is a subtask with a lift prerequisite, and the two placements are composed in this order. Let pX=(pX,xy,zX)p_X=(p_{X,xy},z_X) and hXh_X be cube XX’s center and half-height. The task map extracts y=(pR,pG,pB)y=(p_R,p_G,p_B). For each placement of XX on YY,

dXY=∥pX,xy−pY,xy∥2,eXY=zX−zY−(hX+hY),(21)d_{XY}=\lVert p_{X,xy}-p_{Y,xy}\rVert_2,\qquad e_{XY}=z_X-z_Y-(h_X+h_Y), \tag*{(21)}

where dXYd_{XY} is the horizontal distance between the two centers and eXYe_{XY} the vertical gap between the bottom face of XX and the top face of YY, assuming upright faces.

Placement residual. Dropping the placement subscripts, the lift gate ℓ(e)=s((e−alo)/(ahi−alo))\ell(e)=s((e-a_{\mathrm{lo}})/(a_{\mathrm{hi}}-a_{\mathrm{lo}})) measures how far the cube has been raised relative to its support, and A(d)=1−s((d−dlo)/(dhi−dlo))A(d)=1-s((d-d_{\mathrm{lo}})/(d_{\mathrm{hi}}-d_{\mathrm{lo}})) measures horizontal alignment. The vertical target z⋆(d)=c[1−A(d)]z_\star(d)=c[1-A(d)] equals the carry clearance cc far from alignment and approaches zero near it, a curved valley that rewards carrying before lowering. With error scales τxy,τz\tau_{xy},\tau_z, a vertical weight λz\lambda_z, and a small pre-positioning λpre∈[0,1)\lambda_{\mathrm{pre}}\in[0,1),

Exy(d)=d2/τxy2,U0(d,e)=λz(e−c)2/τz2+λpreExy(d),Q(d,e)=Exy(d)+λz[e−z⋆(d)]2/τz2,U=U0+Dˉ.(22)\begin{aligned} E_{xy}(d)&=d^2/\tau_{xy}^2, & U_0(d,e)&=\lambda_z(e-c)^2/\tau_z^2+\lambda_{\mathrm{pre}}E_{xy}(d),\\ Q(d,e)&=E_{xy}(d)+\lambda_z[e-z_\star(d)]^2/\tau_z^2, & U&=U_0+\bar{D}. \tag*{(22)} \end{aligned}

Here ExyE_{xy} is the horizontal misalignment in units of the error scale. The lift cost U0U_0 penalizes the deviation of the gap from the carry clearance cc, and its small horizontal term moves the cube toward its support while it is lifted. The placement cost QQ penalizes the horizontal misalignment and the deviation of the gap from the valley z⋆(d)z_{\star}(d), so that the cube is lowered as it aligns. The error scales make both costs dimensionless, and λz\lambda_z weighs vertical against horizontal error. Once the cube is lifted, an alignment basin falign(d)=d2/(d2+σalign2)f_{\mathrm{align}}(d) = d^2/(d^2 + \sigma_{\mathrm{align}}^2) ranks completed placements by centring, and the residual is

ϕ(d,e)=[1−ℓ(e)]U(d,e)+ℓ(e)[Q(d,e)+λalignfalign(d)].(23)\phi(d,e) = [1-\ell(e)]U(d,e) + \ell(e)\left[Q(d,e) + \lambda_{\mathrm{align}}f_{\mathrm{align}}(d)\right]. \tag*{(23)}

In the transition band, e<0e < 0 and 0≤z⋆≤c0 \le z_{\star} \le c give Q+λalignfalign−U0≤(1−λpre)Exy+λalignQ + \lambda_{\mathrm{align}}f_{\mathrm{align}} - U_0 \le(1-\lambda_{\mathrm{pre}})E_{xy} + \lambda_{\mathrm{align}}, so the rule in (16) is met by

Dˉ=(1−λpre)sup⁡(d,e)∈ΩExy(d)+λalign.(24)\bar{D} = (1-\lambda_{\mathrm{pre}})\sup_{(d,e)\in\Omega} E_{xy}(d) + \lambda_{\mathrm{align}}. \tag*{(24)}

The gate residual ϕRGg\phi^{g}_{RG} 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,

Vstack(y)=ϕRGg(y)+[1−χ(ϕRGg(y))]Bˉ+χ(ϕRGg(y))ϕBRg(y),(25)V_{\mathrm{stack}}(y) = \phi^{g}_{RG}(y) + [1-\chi(\phi^{g}_{RG}(y))]\bar{B} + \chi(\phi^{g}_{RG}(y))\phi^{g}_{BR}(y), \tag*{(25)}

which by Proposition 3 is C1C^1 on Ω\Omega and vanishes exactly at the geometric stack dRG=eRG=dBR=eBR=0d_{RG} = e_{RG} = d_{BR} = e_{BR} = 0: each residual vanishes only where ℓ=1\ell= 1, Q=0Q = 0, and falign=0f_{\mathrm{align}} = 0, that is, at d=e=0d=e=0. 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 ϕ\phi of (23). Appendix § 14.§ 6 compares it with a potential that builds both placements from the gate residual ϕg\phi^{\mathsf{g}}. 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 p⊥∈R2\boldsymbol{p}_{\perp} \in\mathbb{R}^{2} be the horizontal offset of its center from the peg axis, R∈SO(3)R \in SO(3) its orientation and zz its height. The task map extracts y=(p⊥,R,z)y=(\boldsymbol{p}_{\perp},R,z) for both nuts.

Alignment energy. With the native lateral tolerance τr\tau_{r} and u=∥p⊥∥/τru=\lVert\boldsymbol{p}_{\perp}\rVert/\tau_{r}, the lateral error is quadratic inside the native tolerance and linear outside it, h(u)=u2h(u)=u^{2} for u≤1u\leq1 and h(u)=2u−1h(u)=2u-1 otherwise, so that it stays C1C^{1} and grows slowly far from the peg. Tilt is measured by etilt=1−nz2e_{\mathrm{tilt}}=1-n_{z}^{2} with n=Rezn=R\boldsymbol{e}_{z}, the nut’s axis. The square hole also needs yaw alignment up to its fourfold symmetry, measured with a=Rexa=R\boldsymbol{e}_{x} by

eyaw=8ax2ay2(ax2+ay2)2+ϵ,q=h(u)+λtiltetilt+λyaweyaw,(26)e_{\mathrm{yaw}}=\frac{8a_{x}^{2}a_{y}^{2}}{(a_{x}^{2}+a_{y}^{2})^{2}+\epsilon},\qquad q=h(u)+\lambda_{\mathrm{tilt}}e_{\mathrm{tilt}}+\lambda_{\mathrm{yaw}}e_{\mathrm{yaw}}, \tag*{(26)}

which vanishes when an edge of the nut is parallel to an axis of the peg. The round nut has λyaw=0\lambda_{\mathrm{yaw}}=0.

Nut residual. An alignment valve v(q)=s((qhi−q)/(qhi−qlo))v(q)=s((q_{\mathrm{hi}}-q)/(q_{\mathrm{hi}}-q_{\mathrm{lo}})), with ss the clamped cubic step of (14), opens as the nut aligns. The height cost of an aligned nut, H(z)=Hˉs(∣z−zseat∣/(zapp−zseat))≤HˉH(z)=\bar{H}s(|z-z_{\mathrm{seat}}|/(z_{\mathrm{app}}-z_{\mathrm{seat}}))\leq\bar{H}, vanishes at the seated height zseatz_{\mathrm{seat}} and saturates at the approach height zappz_{\mathrm{app}} above the peg. A nut counts as resting on the table when it is laterally misaligned and not lifted: with the lift indicator μ(z)=s((z−zlift)/hlift)\mu(z)=s((z-z_{\mathrm{lift}})/h_{\mathrm{lift}}) and the lateral valve vlat=s((qhi−h(u))/(qhi−qlo))v_{\mathrm{lat}}=s((q_{\mathrm{hi}}-h(u))/(q_{\mathrm{hi}}-q_{\mathrm{lo}})), its resting indicator is ω=(1−vlat)(1−μ(z))\omega=(1-v_{\mathrm{lat}})(1-\mu(z)). The residual is

ϕ=(1−ω)q+ω[m(q)+Llift]+v(q)H(z)+[1−v(q)]Hˉ,(27)\phi=(1-\omega)q+\omega\bigl[m(q)+L_{\mathrm{lift}}\bigr]+v(q)H(z)+[1-v(q)]\bar{H}, \tag*{(27)}

where mm is a nondecreasing C1C^{1} smoothing of max⁡(q,qrest)\max(q,q_{\mathrm{rest}}) with a quadratic corner of width δrest\delta_{\mathrm{rest}}, and qrestq_{\mathrm{rest}} bounds the alignment energy on Ω\Omega.

Properties. On Ω\Omega, aligning a nut at fixed height never raises ϕ\phi: for a lifted nut or one over its peg, ω=0\omega=0 and ∂ϕ/∂q=1+v′(q)[H(z)−Hˉ]≥1\partial\phi/\partial q=1+v'(q)[H(z)-\bar{H}]\geq1, since v′≤0v'\leq0 and H≤HˉH\leq\bar{H}, and for a resting nut mm is nondecreasing. A misaligned nut has height cost Hˉ\bar{H} at any height and an aligned one has H(z)H(z), so lowering an aligned nut to its seat decreases ϕ\phi. A nut resting away from its peg (ω=1\omega=1) costs qrest+Llift+Hˉq_{\mathrm{rest}}+L_{\mathrm{lift}}+\bar{H} wherever it lies: pushing or turning it on the table leaves ϕ\phi unchanged, lifting it decreases ϕ\phi, and dropping a carried nut increases ϕ\phi. Since zliftz_{\mathrm{lift}} 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 ϕsq\phi_{\mathrm{sq}} as first stage, also used as gate residual, and the round-nut residual ϕrd\phi_{\mathrm{rd}} as second,

Vnut(y)=ϕsq(y)⏟first placement+[1−χ(ϕsq(y))]Bˉ⏟reserve while the second placement is inactive+χ(ϕsq(y))ϕrd(y)⏟second placement, once activated,(28)V_{\mathrm{nut}}(y) = \underbrace{\phi_{\mathrm{sq}}(y)}_{\text{first placement}} + \underbrace{\left[1-\chi\left(\phi_{\mathrm{sq}}(y)\right)\right]\bar{B}}_{\text{reserve while the second placement is inactive}} + \underbrace{\chi\left(\phi_{\mathrm{sq}}(y)\right)\phi_{\mathrm{rd}}(y)}_{\text{second placement, once activated}}, \tag*{(28)}

with the completion gate of (18) and Bˉ≥sup⁡Ωϕrd\bar{B}\ge\sup_{\Omega}\phi_{\mathrm{rd}}, so that by Proposition 3 VnutV_{\mathrm{nut}} is C1C^1 on Ω\Omega 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 90∘90^\circ, a set much smaller than the tolerances of the native success check. Flipped nuts are not excluded. Outside Ω\Omega the potential remains C1C^1 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 VV (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 VkV_k, 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 (1−γk)Vk(1-\gamma_k)V_k, which drives the convergence of Theorem 1.

  • Bounded transient. It stays below (1+dk)Vk(1+d_k)V_k, 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 VkV_k (dotted). Endpoint-only bounds only the last sample, the plateau adds a uniform bound (1+δ)Vk(1+\delta)V_k, 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 (1+δ)Vk(1+\delta)V_k to the endpoint-only funnel.

  • Linear decreases at a constant rate from VkV_k 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 α\alpha (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 tit_i of the chunk, judged from the end of the first control step as for the funnels, the V˙≤0\dot{V} \le0 objective is the smooth maximum 1βlog⁡∑iexp⁡(βV˙i)\frac{1}{\beta}\log\sum_i \exp(\beta\dot{V}_i) with β=10\beta=10, where V˙i\dot{V}_i is the kinematic time derivative of VV on PushT and the difference V(ti)−V(ti−1)V(t_i)-V(t_{i-1}) on stacking. It penalizes any increase of VV within the chunk. The ΣV\Sigma V objective is the running cost ∑iV(ti)\sum_i V(t_i), the cost of a model-predictive controller on VV. Neither defines an envelope, so their searches use a single patience PuP_u on the improvement of the objective, together with the generation cap and numerical stopping.

Funnel Families

Fixed shapes. With normalized chunk time s=t/Hs=t/H, the endpoint-only, plateau and linear funnels have fixed parameters,

ρkend(t)={V‾,s<1,(1−γ)Vk,s=1,ρklin(t)=Vk(1−γs),\rho_k^{\mathrm{end}}(t)= \begin{cases} \overline{V}, & s<1,\\ (1-\gamma)V_k, & s=1, \end{cases} \qquad \rho_k^{\mathrm{lin}}(t)=V_k(1-\gamma s),
ρkpl(t)=Vk[1+(η+(δ−η)S(s/s0))(1−F(s))−γF(s)](29)\rho_k^{\mathrm{pl}}(t)=V_k\left[1+\left(\eta+(\delta-\eta)S(s/s_0)\right)(1-F(s))-\gamma F(s)\right] \tag*{(29)}

where V‾\overline{V} is a constant far above any reachable VV, so that endpoint-only leaves the interior samples free, and S(u)=v2(3−2v)S(u)=v^2(3-2v) with v=clip⁡(u,0,1)v=\operatorname{clip}(u,0,1) is the clamped cubic step of (14). In the plateau, F(s)=S((s−1+s0)/s0)F(s)=S((s-1+s_0)/s_0) moves the envelope to its terminal value at the end of the chunk. The plateau rises from (1+η)Vk(1+\eta)V_k to (1+δ)Vk(1+\delta)V_k over the first fraction s0s_0 of the chunk, holds it, and falls to (1−γ)Vk(1-\gamma)V_k over the last, with η=γ=0.1\eta=\gamma=0.1 and δ∈{0.5,1,3}\delta\in\{0.5,1,3\}. The ramps make the envelope continuous, and therefore Lipschitz, at both ends of the chunk. We set s0=0.02s_0=0.02, an arbitrary small value, so that the plateau holds over almost the whole chunk. For a fixed γ>0\gamma>0, 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 V‾\overline{V} 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

ρk(t)=Vk−γkVkDσk(s)+δkbτk(s)+ηkc0(s),(30)\rho_k(t) = V_k - \gamma_k V_k D_{\sigma_k}(s) + \delta_k b_{\tau_k}(s) + \eta_k c_0(s), \tag*{(30)}

with the profiles

Dσ(s)=max⁡(0,s−σ1−σ),bτ(s)={S(s/τ),s≤τ,S((1−s)/(1−τ)),s>τ,c0(s)=1−S(s),(31)D_\sigma(s) = \max\left(0,\frac{s-\sigma}{1-\sigma}\right), \qquad b_\tau(s) = \begin{cases} S(s/\tau), & s \le\tau,\\ S((1-s)/(1-\tau)), & s > \tau, \end{cases} \qquad c_0(s) = 1-S(s), \tag*{(31)}

where SS is the clamped cubic step defined above. The descent DσD_\sigma ramps from 0 at the onset s=σs=\sigma to 1 at s=1s=1, the bump bτb_\tau peaks at s=τs=\tau, and c0c_0 decays from 1 to 0. Here γk∈[0,1]\gamma_k \in[0,1] is the requested relative progress, δk\delta_k and ηk\eta_k are the transient and start allowances, τk\tau_k is the bump time and σk\sigma_k the descent onset. In the additive family the allowances are in units of VV, scaled by the median training value of VkV_k. The multiplicative family takes them as fractions of the current value,

ρk(t)=Vk[1−γkDσk(s)+δkbτk(s)+ηkc0(s)],(32)\rho_k(t) = V_k\left[1-\gamma_kD_{\sigma_k}(s)+\delta_k b_{\tau_k}(s)+\eta_k c_0(s)\right], \tag*{(32)}

so that the funnel shrinks with VkV_k 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 s=0s=0, Dσ=bτ=0D_\sigma=b_\tau=0 and c0=1c_0=1, so ρk(0)=Vk+ηk\rho_k(0)=V_k+\eta_k in the additive family and (1+ηk)Vk(1+\eta_k)V_k in the multiplicative one. The funnel starts at VkV_k raised by the start allowance, which we floor at $0.1V_k ({xref}Appendix F.2`), and c0c_0 fades this allowance over the chunk.

  • Terminal contraction. At s=1s=1, Dσ=1D_\sigma=1 and bτ=c0=0b_\tau=c_0=0, so ρk(H)=(1−γk)Vk\rho_k(H)=(1-\gamma_k)V_k 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 [0,1][0,1], and the descent term only lowers the envelope. The multiplicative family therefore stays below (1+δk+ηk)Vk(1+\delta_k+\eta_k)V_k, which gives dk=δk+ηkd_k=\delta_k+\eta_k. The additive family stays below Vk+δk+ηkV_k+\delta_k+\eta_k, which gives dk=(δk+ηk)/Vkd_k=(\delta_k+\eta_k)/V_k, a relative bound that grows as VkV_k decreases (Appendix § 13.§ 5).

  • Lipschitz in time. The clamped cubic step is C1C^1 with largest slope 3/23/2. The bump rises over [0,τ][0,\tau] and falls over [τ,1][\tau,1], with zero slope at its peak, so its slope is at most 3/(2min⁡(τ,1−τ))3/(2\min(\tau,1-\tau)), and c0c_0 has slope at most 3/23/2. The ramp is Lipschitz with slope 1/(1−σ)1/(1-\sigma), including at its onset. With the bump time in [0.1,0.9][0.1,0.9] and the onset before the last sample, every fitted envelope is therefore Lipschitz in tt with constant at most

Lρk≤1H(γkVk1−σk+3δk2min⁡(τk,1−τk)+3ηk2),(33)L_{\rho_k} \le\frac{1}{H}\left(\frac{\gamma_k V_k}{1-\sigma_k}+\frac{3\delta_k}{2\min(\tau_k,1-\tau_k)}+\frac{3\eta_k}{2}\right), \tag*{(33)}

with δk\delta_k and ηk\eta_k multiplied by VkV_k in the multiplicative family.

The remaining parameters fit the shape to the demonstrations: δk\delta_k sets the size of the transient allowance and τk\tau_k its timing, and σk\sigma_k 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 HH starting at boundary kk gives the initial value VkV_k, the clipped relative endpoint progress pk=clip⁡(1−Vk+1/Vk,0,1)p_k = \operatorname{clip}(1 - V_{k+1}/V_k, 0, 1), and the interior trace V(ti)V(t_i), 1<i<n1 < i < n. 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 τ=0.5\tau= 0.5 and σ=0\sigma= 0, and the progress γ\gamma is the 10% quantile of the progress labels pkp_k of the training chunks. The two allowances share one scale, δ=η=c\delta= \eta= c. Since the envelope is affine in (δ,η)(\delta,\eta) at fixed γ\gamma, each calibration chunk has a smallest scale ckc_k 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 ckc_k over its chunks, so an episode is contained at scale cc when all its included interior samples lie inside the funnel. With nn calibration episodes, we set cc to the ⌈(n+1)⋅0.9⌉\lceil(n+1)\cdot0.9\rceil-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 πϑ\pi_{\vartheta} reads the same observation history as the policy and is trained with the pinball loss ℓq(u)=max⁡(qu,(q−1)u)\ell_q(u)=\max(qu,(q-1)u), whose minimizer is the qq-quantile of uu [40]. At leniency α\alpha the three heads minimize

Lγ=∑kℓ1−α(pk−γϑ(ok)),Ltr=∑k1max⁡(Vk,1)ℓα(max⁡1<i<n[V(ti)−ρk(ti;sg⁡[γk])]),Lσ=∑k:pk>0ℓα(σklab−σϑ(ok)).(34)\begin{aligned} \mathcal{L}_{\gamma} &= \sum_k \ell_{1-\alpha}(p_k-\gamma_{\vartheta}(o_k)),\\ \mathcal{L}_{\mathrm{tr}} &= \sum_k \frac{1}{\max(V_{k,1})}\ell_{\alpha}\left(\max_{1<i<n}[V(t_i)-\rho_k(t_i;\operatorname{sg}[\gamma_k])]\right),\\ \mathcal{L}_{\sigma} &= \sum_{k:p_k>0}\ell_{\alpha}(\sigma_k^{\mathrm{lab}}-\sigma_{\vartheta}(o_k)). \tag*{(34)} \end{aligned}

Their minimizers satisfy the conditional quantile conditions

Pr⁡(pk≥γk∣ok)≈α,Pr⁡(max⁡1<i<n[V(ti)−ρk(ti)]≤0 | ok)≈α,(35)\Pr(p_k\ge\gamma_k\mid o_k)\approx\alpha,\qquad \Pr\left(\max_{1<i<n}[V(t_i)-\rho_k(t_i)]\le0\ \middle|\ o_k\right)\approx\alpha, \tag*{(35)}

These are two separate marginal targets over demonstrated chunks. The first states that the requested endpoint progress is met on a fraction α\alpha of the chunks, and the second that the interior allowance contains the trace on a fraction α\alpha of the chunks. A larger α\alpha lowers the requested progress and widens the allowance, which gives a more permissive funnel. We clip the demonstrated relative progress to [0,1][0,1], so a chunk that regresses at its endpoint supplies a zero-progress target, and the predicted γk\gamma_k 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 Ltr\mathcal{L}_{\mathrm{tr}} within each epoch. The initial sample is covered by the start allowance and is therefore left out of the transient target. The onset labels σklab\sigma_k^{\mathrm{lab}} 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, α∈{0.5,0.8,0.9,0.95}\alpha\in\{0.5,0.8,0.9,0.95\}. Its parameterization makes γ\gamma nonincreasing and δ\delta, η\eta, σ\sigma nondecreasing in α\alpha, with a shared τ∈[0.1,0.9]\tau\in[0.1,0.9] and onset no later than the last interior sample, so higher levels give nested, more permissive envelopes. Training uses AdamW (learning rate 10−310^{-3}, weight decay 10−410^{-4}, 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 a∈Rda \in\mathbb{R}^{d}, CMA-ES samples aℓ=m+σBDϵℓa_{\ell} = m + \sigma B D \epsilon_{\ell} with ϵℓ∼N(0,Id)\epsilon_{\ell} \sim\mathcal{N}(0,I_{d}), where mm is the distribution mean, σ\sigma the step size, and C=BD2B⊤C = B D^{2} B^{\top} the eigendecomposition of the search covariance CC. Every evaluated seed is Ψ(aℓ)\Psi(a_{\ell}), with Ψ\Psi from (9), and degenerate or non-finite inputs are rejected. The projection first centers the seed, subtracting the mean aˉ\bar{a} of its dd 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, m←Ψ(m)m \leftarrow\Psi(m). 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 aˉ\bar{a} 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 ∥a−aˉ1∥22∼χd−12\lVert a-\bar{a}\mathbf{1}\rVert_{2}^{2} \sim\chi_{d-1}^{2}. We place the band endpoints at tail probabilities Φ(−ζ)\Phi(-\zeta) and Φ(ζ)\Phi(\zeta) using the Wilson–Hilferty approximation (Wilson and Hilferty, 1931). With ν=d−1\nu=d-1 and b=2/(9ν)b=2/(9\nu),

rlo=ν(1−b−ζb)3,rhi=ν(1−b+ζb)3.(36)r_{\mathrm{lo}}=\sqrt{\nu(1-b-\zeta\sqrt{b})^{3}}, \qquad r_{\mathrm{hi}}=\sqrt{\nu(1-b+\zeta\sqrt{b})^{3}}. \tag*{(36)}

The approximation is used for ν≥30\nu\ge30. Fixing both radii to ν\sqrt{\nu} recovers the single-sphere projection of standardized CMA-ES (Stölzle et al., 2026). We use ζ=4\zeta=4: a source draw then lies outside the band with probability about 6×10−56\times10^{-5}, 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 dd equal to the chunk length times the width of the action representation (for stacking, 32×8=25632 \times8 = 256). 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 ap∈R3a_{p} \in\mathbb{R}^{3}, a rotation vector aR∈R3a_{R} \in\mathbb{R}^{3}, and a gripper coordinate ar∈Ra_{r} \in\mathbb{R}, so d=7×32=224d=7\times32=224 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 S=diag⁡(1,1,1,σrot,σrot,1)S=\operatorname{diag}(1,1,1,\sigma_{\mathrm{rot}},\sigma_{\mathrm{rot}},1),

z0=C(Ψ(a)),C(ap,aR,ar)=(ap,Rˉexp⁡(σrot[aR]×),ar),(37)z_{0}=\mathcal{C}(\Psi(a)), \qquad\mathcal{C}(a_{p},a_{R},a_{r})=\left(a_{p},\bar{R}\exp(\sigma_{\mathrm{rot}}[a_{R}]_{\times}),a_{r}\right), \tag*{(37)}

which matches (12). Then z0z_{0} is written in the 13-dimensional carrier that the flow evolves. In these coordinates the source is exactly a∼N(0,Id)a\sim\mathcal{N}(0,I_{d}), 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: xkx_k, oko_k, frozen ρk\rho_k, nominal source coordinates anoma^{\mathrm{nom}}

Jref←+∞J_{\mathrm{ref}} \leftarrow+\infty; p←0p \leftarrow0; initialize (m,σ,C)(m,\sigma,C) on the band

for g=1,2,…g = 1, 2, \ldots do

a1←anoma_1 \leftarrow a^{\mathrm{nom}} if g=1g=1; otherwise a1∼N(m,σ2C)a_1 \sim\mathcal{N}(m,\sigma^2C); aℓ∼N(m,σ2C)a_\ell\sim\mathcal{N}(m,\sigma^2C), ℓ=2,…,λ\ell=2,\ldots,\lambda

wℓ←Decode⁡(aℓ;ok)w_\ell\leftarrow\operatorname{Decode}(a_\ell;o_k); Jℓ←Cost⁡(wℓ;xk,ρk)J_\ell\leftarrow\operatorname{Cost}(w_\ell;x_k,\rho_k), ℓ=1,…,λ\ell=1,\ldots,\lambda ▷ in parallel

if g=1g=1 then (w⋆,J⋆)←(w1,J1)(w^\star,J^\star)\leftarrow(w_1,J_1); Jnom←J1J_{\mathrm{nom}}\leftarrow J_1 ▷ projected nominal plan

Rank-update (m,σ,C)(m,\sigma,C) from J1:λJ_{1:\lambda}; m←Ψ(m)m\leftarrow\Psi(m)

ℓ′←arg⁡min⁡ℓJℓ\ell^\prime\leftarrow\arg\min_\ell J_\ell; if Jℓ′<J⋆J_{\ell^\prime}<J^\star then (w⋆,J⋆)←(wℓ′,Jℓ′)(w^\star,J^\star)\leftarrow(w_{\ell^\prime},J_{\ell^\prime})

if J⋆<Jref−TJ^\star<J_{\mathrm{ref}}-T then p←0p\leftarrow0; Jref←J⋆J_{\mathrm{ref}}\leftarrow J^\star else p←p+1p\leftarrow p+1 ▷ threshold TT of Eq. (38)

if w⋆w^\star changed then v⋆←Verify⁡(w⋆)v^\star\leftarrow\operatorname{Verify}(w^\star)

if p≥P(v⋆)p\ge P(v^\star) (patience, when enabled) or the time budget is spent then stop

if numerical degeneracy or generation cap then stop

end

return (w⋆,J⋆,v⋆)(w^\star,J^\star,v^\star)

Function Verify⁡(w)\operatorname{Verify}(w)

gi←V(T(x(ti)))−ρk(ti)g_i\leftarrow V(T(x(t_i)))-\rho_k(t_i) on the stored rollout of ww

L^i←\hat{L}_i\leftarrow local rates from g1:ng_{1:n} ▷ Appendix § 13.§ 5

return [B^k≤0][\hat{B}_k\le0], with B^k\hat{B}_k from (6) at rates L^i\hat{L}_i

P(v)=PvP(v)=P_v if v=1v=1, else PuP_u; Cost⁡()\operatorname{Cost}() and Decode⁡()\operatorname{Decode}() as in Algorithm 1

Best plan and stopping. CMA-ES updates its distribution from the ranks of the unnormalized log-sum-exp JkJ_k 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 v⋆∈{0,1}v^\star\in\{0,1\} 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 J⋆<Jref−TJ^\star<J_{\mathrm{ref}}-T with

T=max⁡(ϵabs,ϵrel(Jnom−Jref)).(38)T=\max(\epsilon_{\mathrm{abs}},\epsilon_{\mathrm{rel}}(J_{\mathrm{nom}}-J_{\mathrm{ref}})). \tag*{(38)}

where JnomJ_{\mathrm{nom}} is the objective of the projected nominal plan and JrefJ_{\mathrm{ref}} is the best objective at the last generation that counted as progress. JrefJ_{\mathrm{ref}} is then reset to J⋆J^\star. It starts at +∞+\infty, so the first generation always counts as progress. Small gains accumulate until they clear TT, and scaling ϵrel\epsilon_{\mathrm{rel}} by the improvement already achieved makes the rule invariant to the offset of the objective. JrefJ_{\mathrm{ref}} is used by this stopping rule and does not enter the objective. The search stops after PP generations without progress, with P=PvP=P_v when the best plan passes estimated verification and P=PuP=P_u otherwise. The shorter PvP_v 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.

ParameterSetting
Population / parents20/10 (λ=4+⌊3ln⁡d⌋\lambda= 4 + \lfloor3 \ln d \rfloor)
Initial step size / generation cap1/30
Covariance eigendecompositionEvery generation
Seed regionBand with ζ=4\zeta= 4, one global group; mean projected after each update
Meaningful improvementϵabs=10−2\epsilon_{\mathrm{abs}} = 10^{-2}, ϵrel=5×10−3\epsilon_{\mathrm{rel}} = 5 \times10^{-3} (relative to achieved improvement)
PatiencePu=6/Pv=4P_u = 6 / P_v = 4 generations (best plan not verified / verified)
VerificationEstimated, window wL=0.02 sw_L = 0.02\ \mathrm{s}, on the physics-step grid
Start allowanceηk≥0.1Vk\eta_k \ge0.1 V_k
Ranked samplesFrom the end of the first control step
Objective temperatureβ=10\beta= 10 (PushT), β=50\beta= 50 (stacking)
Numerical stoppingσλmax⁡(C)<10−12\sigma\sqrt{\lambda_{\max}(C)} < 10^{-12} or cond⁡(C)>1014\operatorname{cond}(C) > 10^{14}

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 aa by descending Fk(a)=Jk(ψθ(1∣a,ok))F_k(a)=J_k(\psi_\theta(1\mid a,o_k)) of § 4, with the rollout Rk\mathcal{R}_k 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 CVaR90_{90}. 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.

SearchSucc.↑CVaR10_{10} ↑MaxFinalMeanCVaR90_{90}KLLDJ↑JumpOOD%↓KIDOOD%KID
Nominal31.5.000.795.68833.367.5.363−9.92.5444.0.2593.2.286
Adam†60.5.647.927.91819.151.6.045−10.12.6525.8.1624.5.181
L-BFGS†70.0.765.942.93819.547.4.012−10.15.66212.0.19610.7.154
Best-of-NN82.5.768.948.94019.950.5.054−9.87.5134.9.1754.0.194
CEM79.0.848.954.95018.747.3.014−10.28.6008.0.1436.2.141
MPPI83.0.914.960.95818.546.8.041−9.97.60610.8.2249.8.177
CMA-ES, no band96.0.941.963.96315.345.9.022−10.96.68234.11.3932.5.996
CMA-ES, sphere84.5.794.949.94419.249.5.033−9.62.5576.6.1665.1.152
Ours, ζ=2\zeta=287.0.873.957.95518.045.3.012−9.78.5589.5.2177.5.180
Ours, ζ=3\zeta=383.0.855.954.95118.350.3.008−9.91.5639.4.1778.2.155
Ours, ζ=4\zeta=486.5.877.957.95618.647.0.012−9.93.56211.3.2209.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 x=(pa,va,pb,θb,ξb)∈R10x = (p_a, v_a, p_b, \theta_b, \xi_b) \in\mathbb{R}^{10} 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 (Δt=0.01 s\Delta t = 0.01\ \mathrm{s}) follows Chipmunk’s order. The agent’s kinematic Proportional–Derivative (PD) controller updates va←va+(kp(u−pa)−kvva)Δtv_a \leftarrow v_a + (k_p(u-p_a)-k_vv_a)\Delta t with the held target uu, kp=225k_p = 225 and kv=30k_v = 30. 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 nn, with arm rr from the center of mass and block inverse inertia M−1=diag⁡(1/m,1/m,1/I)M^{-1} = \operatorname{diag}(1/m, 1/m, 1/I), the impulse along c=(n,r×n)c = (n, r \times n) is λ=Δ/(cTM−1c)\lambda= \Delta/(c^{\mathsf{T}}M^{-1}c) for the missing normal speed Δ\Delta, 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),

h(pa)=1βclog⁡∑j=1meβcsj(pa)−0.4log⁡mβc,n^=∇pah∥∇pah∥(39)h(p_a) = \frac{1}{\beta_c}\log\sum_{j=1}^{m} e^{\beta_c s_j(p_a)} - \frac{0.4\log m}{\beta_c}, \qquad\hat{n} = \frac{\nabla_{p_a} h}{\lVert\nabla_{p_a} h \rVert} \tag*{(39)}

where sjs_j is the separation of the disc and the part along the jj-th of mm axes, the edge normals of the part and the directions from the disc center to its vertices, and βc=80\beta_c = 80. The log-sum-exp is a smooth maximum over the axes, and the shift keeps it from overestimating the true separation. The contact normal n^\hat{n} 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 g=sigmoid⁡(−h/wc)g = \operatorname{sigmoid}(-h/w_c), wc=0.1w_c = 0.1 px, and its impulse is updated by

Δλ=gΔcTM−1c−(1−g)λ,λ←g sp⁡wi(λ),sp⁡w(x)=wlog⁡(1+ex/w),(40)\Delta\lambda= \frac{g\Delta}{\mathbf{c}^{\mathsf{T}}M^{-1}\mathbf{c}} - (1-g)\lambda,\qquad\lambda\leftarrow g\,\operatorname{sp}_{w_i}(\lambda),\qquad\operatorname{sp}_{w}(x)=w\log(1+e^{x/w}), \tag*{(40)}

a soft constraint whose fixed point does not depend on the number of passes, a hard contact for g=1g = 1 and no constraint for g=0g = 0. The softplus of width wi=1w_i = 1 px/s replaces the clamp max⁡(λ,0)\max(\lambda, 0), 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 e−40e^{-40}, 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 512×512512 \times512 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 xkx_k, and evaluates JkJ_k 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 VV 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 sTy>10−10∥s∥∥y∥s^{\mathsf{T}}y > 10^{-10}\lVert s\rVert\lVert y\rVert, restarts along −∇Fk-\nabla F_k when the direction is not a descent direction, and selects the step by Armijo backtracking (c1=10−4c_1 = 10^{-4}, 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 (∥∇Fk∥≤10−6(1+∣Fk∣)\lVert\nabla F_k\rVert\leq10^{-6}(1+\lvert F_k\rvert)), 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 [−1,1][-1,1] 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 [−1,1][-1,1], 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 [0,1][0,1]. The model regresses the corresponding path velocity with normalized weighted squared error,

L(θ)=E[∑i,jωj(uθ,ij−ui,j∗)2∑i,jωj],(41)\mathcal{L}(\theta) = \mathbb{E}\left[\frac{\sum_{i,j}\omega_j\left(u_{\theta,ij}-u^*_{i,j}\right)^2}{\sum_{i,j}\omega_j}\right], \tag*{(41)}

where ii indexes waypoint tokens and jj 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 10−410^{-4} and aXY=Overlap⁡(X,Y)⋅Contact⁡(X,Y)a_{XY} = \operatorname{Overlap}(X,Y) \cdot\operatorname{Contact}(X,Y), the projected footprint overlap of XX on YY times their contact.

weight decay 10−610^{-6}, linear warmup followed by cosine decay to 10−610^{-6}, 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.

PushTThree-cube stackingTwo-nut assembly
Demonstrations20610001000
Training iterations30k100k100k
Batch size / warmup128 / 500 steps128 / 1000 steps128 / 1000 steps
Prediction / history24 waypoints / 2 steps32 waypoints / 5 steps32 waypoints / 2 steps
Execution horizon24 steps32 steps32 steps
State features ×\times history6×2=126 \times2 = 1274×5=37074 \times5 = 37053×2=10653 \times2 = 106
NetworkU-Net (FiLM)DiTDiT
FlowOTRMFMRMFM
Waypoint targetAgent positionEE pose + gripper commandEE pose + gripper command
Network channels (in/out)2/213/713/7
Flow integration8 Euler steps10 Lie–Euler steps10 Lie–Euler steps
Control / physics rate10 Hz / 100 Hz20 Hz / 500 Hz20 Hz / 500 Hz
Step budget400400600
PotentialPose 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 r∈[0,1]r \in[0, 1]Coverage(block, goal)12aRG(1+aBR)\frac{1}{2}a_{RG}(1 + a_{BR})VV
Successr>0.95r > 0.95Stacked ∧\land OpenSeatedsq∧_{\mathrm{sq}} \land Seatedrd∧_{\mathrm{rd}} \land 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 (kp=225k_p = 225, kv=30k_v = 30). 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.

TaskInitializationTracking
PushTHard reset mode: block in [100,400]2[100, 400]^2, agent in [50,450]2[50, 450]^2Position PD
Cube StackingEach cube placed uniformly in x,y∈[−0.2,0.2]x, y \in[-0.2, 0.2] m with uniform yaw, overlaps rejected (the robosuite placement sampler (Zhu et al., 2020))IK with joint-space PD
Two-Nut AssemblyMimicGen NutAssembly_D0 reset: both nuts placed on the table with uniform yaw, the square nut at x∈[−0.115,−0.110]x \in[-0.115, -0.110], y∈[0.110,0.225]y \in[0.110, 0.225] and the round nut at x∈[−0.115,−0.110]x \in[-0.115, -0.110], y∈[−0.225,−0.110]y \in[-0.225, -0.110], robot at the dataset’s initial joint configurationIK with joint-space PD

Table 7. Environment initialization and tracking.

GainStackingTwo-nut assembly
Task kpk_p (position / rotation)22.88 / 6.2444 / 28
Task kdk_d (position / rotation)1.43 / 1.530.81 / 0.39
Joint kpk_p / kdk_d91.18 / 85.2894.52 / 88
Posture kpk_p / kdk_d1.40 / 0.373.50 / 0.42
DLS damping8×10−48 \times10^{-4}8×10−48 \times10^{-4}
Twist limit (linear / angular)0.75 m/s / 1.5 rad/s0.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 xx and in yy 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 ρ~k(t)=ρk(t)+akc0(t/H)\widetilde{\rho}_k(t) = \rho_k(t) + a_k c_0(t/H), with ak≥0a_k \ge0, c0(0)=1c_0(0) = 1 and c0(1)=0c_0(1) = 0, 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 ϵk≤ϵˉ\epsilon_k \le\bar{\epsilon}, from terminal violation of the funnel or from a mismatch between predicted and executed motion, give the recursion V(yk+1)≤(1−γk)V(yk)+ϵkV(y_{k+1}) \le(1 - \gamma_k)V(y_k) + \epsilon_k, whose endpoint values approach a neighborhood of size ϵˉ/γˉ\bar{\epsilon}/\bar{\gamma} (Appendix § 13.§ 4). Progress accumulated over windows of chunks admits preparatory chunks with γk=0\gamma_k = 0 (Appendix § 13.§ 5).

Convergence: Product Form and Proof of thm:recedinghorizoncontraction

Proposition 4 (Task contraction with iteration-dependent rates). Suppose each selected chunk wk∗w_k^* is executed for the full horizon H>0H > 0 before replanning, its evaluated task rollout matches execution, and it satisfies (3) with the terminal and transient bounds of (2) for some γk∈[0,1]\gamma_k \in[0,1] and dk≥0d_k \ge0. Then, for every m≥1m \ge1,

V(yk+m)≤[∏j=kk+m−1(1−γj)]V(yk),(42)V(y_{k+m}) \le\left[\prod_{j=k}^{k+m-1}(1-\gamma_j)\right] V(y_k), \tag*{(42)}

and sup⁡t∈[0,H]V(ywk∗k(t))≤(1+dk)V(yk)\sup_{t\in[0,H]} V(y_{w_k^*}^k(t)) \le(1+d_k)V(y_k).

Proof. At t=Ht=H, funnel satisfaction gives V(yk+1)≤ρk(H)≤(1−γk)V(yk)V(y_{k+1}) \le\rho_k(H) \le(1-\gamma_k)V(y_k), and iteration yields the product bound. Within iteration kk, the funnel and the transient bound give V(ywk∗k(t))≤ρk(t)≤(1+dk)V(yk)V(y_{w_k^*}^k(t)) \le\rho_k(t) \le(1+d_k)V(y_k).

Proof [Proof of Theorem 1]. Substituting the uniform bounds γk≥γ\gamma_k \ge\gamma and dk≤dˉd_k \le\bar{d} 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 ff 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 q(t)q(t) denote the configuration of the world along the rollout xwkx_w^k, that is, the generalized coordinates of the robot and the objects, without their velocities. Suppose that, for every candidate plan, qq is absolutely continuous on [0,H][0,H] with speed bounded almost everywhere by a common vmax⁡v_{\max}. Let F(q)=V(T(q))F(q)=V(T(q)) be Lipschitz on the reachable set with constant LFL_F, and let every envelope ρk\rho_k be Lipschitz with constant at most LρL_\rho. Then, uniformly over plans, the task residual is Lipschitz on every sampling interval with

Li≤LFvmax⁡+Lρ.(43)L_i \le L_F v_{\max} + L_\rho. \tag*{(43)}

Proof. Bounded speed gives d(q(t),q(s))≤vmax⁡∣t−s∣d(q(t),q(s)) \le v_{\max}|t-s|. Consequently,

∣F(q(t))−F(q(s))∣≤LFvmax⁡∣t−s∣.|F(q(t))-F(q(s))| \le L_Fv_{\max}|t-s|.

Adding the envelope’s Lipschitz bound yields the result.

Configuration trajectories can satisfy these assumptions despite velocity jumps. For a C1C^1 composition FF, a bound on its gradient over a suitable compact neighborhood provides LFL_F, and Appendix § 10 establishes this regularity for the phased construction. For the learned envelope, LρL_\rho is bounded because VkV_k is bounded on Ω\Omega 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, ρk(0)=Vk\rho_k(0)=V_k, every plan starts with a zero residual at the first sample, g1=0g_1=0. The first interval then contributes (g2+L1Δ1)/2(g_2+L_1\Delta_1)/2 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 ηkc0(s)\eta_k c_0(s) in (30) lowers the initial residual to −ηk-\eta_k and vanishes at s=1s=1, so terminal contraction is unchanged. It is part of the frozen envelope and enters the transient bound through dkd_k. A learned predictor may output ηk≈0\eta_k\approx0, since demonstrated chunks start exactly on their anchor. We therefore floor the allowance at a fixed fraction of VkV_k (Appendix § 12.§ 4).

Proof of thm:objectivecertification

On [ti,ti+1][t_i,t_{i+1}] the Lipschitz bound from each endpoint gives gk(w,t)≤min⁡{gi+Li(t−ti),gi+1+Li(ti+1−t)}g_k(w,t)\le\min\{g_i+L_i(t-t_i),g_{i+1}+L_i(t_{i+1}-t)\}. The first term increases and the second decreases in tt, so their minimum is largest where they are equal, at the value (gi+gi+1+LiΔi)/2(g_i+g_{i+1}+L_i\Delta_i)/2. Taking the maximum over the intervals gives (6), and Bk(w)≤0B_k(w)\le0 is funnel satisfaction throughout [0,H][0,H] by the definition of the residual.□

Convergence with a Terminal Error Allowance

Corollary 6 (Practical receding-horizon contraction). Suppose executed chunks satisfy

V(yk+1)≤(1−γk)V(yk)+ϵk,γk∈[γ,1],0≤ϵk≤ϵˉ,V(y_{k+1})\le(1-\gamma_k)V(y_k)+\epsilon_k,\qquad\gamma_k\in[\gamma,1],\qquad0\le\epsilon_k\le\bar{\epsilon},

where γ>0\gamma>0 and ϵˉ\bar{\epsilon} are uniform bounds. Then

V(yk+m)≤(1−γ)mV(yk)+ϵˉ∑j=0m−1(1−γ)j(44)V(y_{k+m})\le(1-\gamma)^m V(y_k)+\bar{\epsilon}\sum_{j=0}^{m-1}(1-\gamma)^j \tag*{(44)}

and lim sup⁡m→∞V(yk+m)≤ϵˉ/γ\limsup_{m\to\infty}V(y_{k+m})\le\bar{\epsilon}/\gamma.

Proof. Nonnegativity of VV permits replacing γk\gamma_k and ϵk\epsilon_k 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 [0,1][0,1], so the learned envelope satisfies the transient bound of (2) with

sup⁡t∈[0,H]ρk(t)≤Vk+δk+ηk,dk=δk+ηkVk.(45)\sup_{t\in[0,H]}\rho_k(t)\le V_k+\delta_k+\eta_k,\qquad d_k=\frac{\delta_k+\eta_k}{V_k}. \tag*{(45)}

The predictor is a continuous network on a bounded feature domain with bounded allowance outputs, so δk+ηk≤aˉ\delta_k+\eta_k\le\bar{a} for some constant aˉ\bar{a}, and

dk≤dˉ=aˉ/vgoalwhenever Vk≥vgoal>0.(46)d_k\le\bar{d}=\bar{a}/v_{\mathrm{goal}}\qquad\text{whenever }V_k\ge v_{\mathrm{goal}}>0. \tag*{(46)}

An additive allowance δk+ηk\delta_k+\eta_k corresponds to the relative allowance (δk+ηk)/Vk(\delta_k+\eta_k)/V_k, which grows as VkV_k decreases. For example, a fixed allowance of 0.1 is 10% of Vk=1V_k=1 and 1000% of Vk=0.01V_k=0.01. The bound dˉ=aˉ/vgoal\bar{d}=\bar{a}/v_{\mathrm{goal}} therefore holds on the region Vk≥vgoalV_k\ge v_{\mathrm{goal}}, and Theorem 1 applies to additive funnels until VV reaches the positive level vgoalv_{\mathrm{goal}}. 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 VV. If, in addition, V(y)≥φG(dist⁡(y,G))V(y)\ge\varphi_G(\operatorname{dist}(y,\mathcal{G})) for a continuous, strictly increasing φG\varphi_G with φG(0)=0\varphi_G(0)=0, convergence of VV implies convergence in distance to G\mathcal{G}.

Progress without a uniform rate. A learned funnel may request no endpoint progress for some chunks, γk=0\gamma_k=0, for instance while the robot regrasps or moves to the next object. The rate in (4) then does not apply, because it assumes γk≥γ>0\gamma_k\ge\gamma>0 at every iteration. The product bound in (42) still holds for any γk∈[0,1]\gamma_k\in[0,1]. The following proposition shows that convergence still holds when requested progress accumulates, either in total or within windows of mm 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 dk≤dˉd_k\le\bar{d} for all kk.

  1. For every kk, sup⁡t∈[0,H]V(ywk∗(t))≤(1+dˉ)exp⁡(−∑j<kγj)V(y0)\sup_{t\in[0,H]} V(y_{w_k^*}(t))\le(1+\bar{d})\exp\left(-\sum_{j<k}\gamma_j\right)V(y_0). Hence, for any tolerance ε∈(0,V(y0))\varepsilon\in(0,V(y_0)), V(yk)≤εV(y_k)\le\varepsilon as soon as ∑j<kγj≥log⁡(V(y0)/ε)\sum_{j<k}\gamma_j\ge\log(V(y_0)/\varepsilon).

  2. If there are m≥1m\ge1 and Γ>0\Gamma>0 such that ∑j=kk+m−1γjV(yj)≥Γ\sum_{j=k}^{k+m-1}\gamma_jV(y_j)\ge\Gamma whenever V(yk)>vgoalV(y_k)>v_{\mathrm{goal}}, then V(yk)≤vgoalV(y_k)\le v_{\mathrm{goal}} for all k≥m⌈(V(y0)−vgoal)/Γ⌉k\ge m\left\lceil(V(y_0)-v_{\mathrm{goal}})/\Gamma\right\rceil.

Proof. (i) Since 1−γ≤e−γ1-\gamma\le e^{-\gamma}, (42) gives V(yk)≤exp⁡(−∑j<kγj)V(y0)V(y_k)\le\exp\left(-\sum_{j<k}\gamma_j\right)V(y_0), and within chunk kk the transient bound adds at most a factor 1+dˉ1+\bar{d}. (ii) Terminal contraction gives V(yj)−V(yj+1)≥γjV(yj)≥0V(y_j)-V(y_{j+1})\ge\gamma_jV(y_j)\ge0, so V(yk)V(y_k) is nonincreasing. Summing over a window that starts outside the goal set gives V(yk)−V(yk+m)≥ΓV(y_k)-V(y_{k+m})\ge\Gamma. At most ⌈(V(y0)−vgoal)/Γ⌉\left\lceil(V(y_0)-v_{\mathrm{goal}})/\Gamma\right\rceil such windows fit before the boundary value falls below vgoalv_{\mathrm{goal}}, 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 γk=0\gamma_k=0, provided some progress is requested in every window of mm chunks. The predictor does not enforce this condition, and it can be checked along executed episodes. Both statements concern chunk boundaries. Within chunk kk the task potential stays below (1+dˉ)V(yk)(1+\bar{d})V(y_k).

Local rates and their estimates. In Theorem 2, LiL_i bounds the rate of the residual on interval ii. We estimate the rate of each interval from the largest nearby secant slope. The local rate L^i\hat{L}_i is the largest secant slope ∣gj+1−gj∣/Δj|g_{j+1}-g_j|/\Delta_j among the intervals jj whose midpoints lie within a window wLw_L of the midpoint of interval ii, with the adjacent intervals always included. Substituting L^i\hat{L}_i 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 ii alone returns max⁡(gi,gi+1)\max(g_i,g_{i+1}) in (6), which is sampled verification. Since L^i\hat{L}_i 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 wLw_L. The guarantee of Theorem 2 applies when the rates upper-bound the true residual rate on each interval, for instance with LFvmax⁡+LρL_Fv_{\max}+L_\rho from Lemma 5.

Search objective and verification. The log-sum-exp JkJ_k of § 4 lies between MkM_k and Mk+log⁡(n)/βM_k + \log(n)/\beta, so Jk≤0J_k \le0 implies sampled verification. JkJ_k and the verdict serve separate purposes. JkJ_k 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 N=400N = 400 episodes and the search comparison N=200N = 200.

For each of 4000 bootstrap replicates, we sample NN 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 ΣV\Sigma V (MPC) the ΣV\Sigma V 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.

SearchSucc. [pts]MeanCVaR10_{10}MeanCVaR90_{90}KLLDJJump
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-NN−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 CVaR10_{10}. The mean final score over the lowest-scoring 10% of episodes. Higher is better.

Maximum drawdown and its CVaR90_{90}. The maximum drawdown of an episode is the largest fall of the score below its earlier peak, max⁡s≤t(rs−rt)\max_{s \le t}(r_s-r_t), in points (×100\times100). The trace 0.2, 0.7, 0.4, 0.8 has a drawdown of 0.3, or 30 points. CVaR90_{90} is the mean drawdown over the 10% of episodes with the largest drawdown, and CVaR95_{95} over the largest 5%. Lower is better. The subscript is the quantile level at which the tail starts, so CVaR10_{10} of a score and CVaR90_{90} of a drawdown both average the worst 10% of episodes.

KL. KL(pmax⁡∥pfinal)\mathrm{KL}(p_{\max} \mathbin\Vert p_{\mathrm{final}}) 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 HH.

V-score. On two-nut assembly, the V-score is 1−V/V01 - V/V_0, with V0=85.3V_0 = 85.3 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 δ∈{1,3}\delta\in\{1,3\} allow VV 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).

FunnelSuccess [%] ↑ PushTSuccess [%] ↑ Stack.Final score ↑ Mean PushTFinal score ↑ Mean Stack.Final score ↑ CVaR10_{10} PushTFinal score ↑ CVaR10_{10} Stack.Max drawdown [pts] ↓ Mean PushTMax drawdown [pts] ↓ Mean Stack.Max drawdown [pts] ↓ CVaR90_{90} PushTMax drawdown [pts] ↓ CVaR90_{90} Stack.KL ↓ PushTKL ↓ Stack.Verified [%] ↑ Executed PushTVerified [%] ↑ Executed Stack.Verified [%] ↑ Nominal PushTVerified [%] ↑ Nominal Stack.
Nominal31.377.0.638.637.000.00040.08.586.946.1.472.181n/an/a
Endpoint-only86.886.0.923.804.560.08428.36.862.846.1.053.060n/an/a
No envelope V˙≤0\dot{V} \le060.585.5.855.744.218.10323.45.854.241.8.153.065n/an/a
ΣV\Sigma V80.082.0.910.715.499.00022.66.454.443.4.052.084n/an/a
Plateau, δ=0.5\delta= 0.573.083.8.905.771.494.07523.96.956.746.2.098.06573.341.948.740.0
Plateau, δ=1\delta= 186.586.5.920.803.529.09127.97.162.946.8.060.04568.840.945.835.4
Plateau, δ=3\delta= 386.885.8.924.805.568.09728.16.762.445.7.053.05469.040.646.235.4
Linear54.578.8.839.662.194.00024.37.654.744.3.219.1080.53.35.59.7
Calibrated per stage–82.8–.792–.101–7.6–48.5–.102–57.6–47.2
Calibrated global88.580.5.927.717.587.00127.47.562.946.2.038.10760.561.215.452.5
Learned add., α=0.5\alpha= 0.584.885.0.925.799.613.16222.97.652.347.0.029.05638.044.37.523.6
Learned add., α=0.8\alpha= 0.871.882.3.900.775.480.06523.16.653.744.8.126.05856.250.818.635.4
Learned add., α=0.95\alpha= 0.9574.382.3.902.767.474.02522.67.052.644.8.126.10162.954.324.641.9
Learned mult., α=0.5\alpha= 0.576.585.8.910.796.542.09523.17.052.546.3.169.06040.542.112.223.5
Learned mult., α=0.8\alpha= 0.871.882.0.906.771.529.06723.28.252.047.6.091.08362.649.228.634.2
Learned mult., α=0.95\alpha= 0.9563.884.0.887.775.424.10723.55.754.040.5.145.05670.754.233.143.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 VV. Two-nut assembly has no such measure finer than the share of seated nuts, r∈{0,12,1}r \in\{0, \frac{1}{2}, 1\}, 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 VV, and compute the final score, drawdown and KL on the V-score 1−V/V01 - V/V_0, where V0=85.3V_0 = 85.3 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 V˙≤0\dot{V} \le0, ΣV\Sigma V, the learned funnels and the plateau at δ=3\delta= 3 (Table 10). Endpoint-only also raises the native score from .873 to .915 and lowers the CVaR90\mathrm{CVaR}_{90} 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 α=0.5\alpha= 0.5 has the lowest values, a CVaR90\mathrm{CVaR}_{90} of 21.2 points and a KL of .034. The plateau at δ=3\delta= 3 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 VV-score and its CVaR10\mathrm{CVaR}_{10}, 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.

FunnelConfigurationSuccess [%] ↑Native score mean ↑Final ↑ MeanFinal ↑ CVaR10Drawdown [pts] ↓ MeanDrawdown [pts] ↓ CVaR90KL ↓Executed ↑Nominal
Nominal80.3.873−.875−.205−5.4−43.2−.192−n/a
Endpoint-only84.5.915.923.4013.630.7.060n/a
No envelopeV˙≤0\dot{V} \le086.8.927.928.3943.430.6.080n/a
No envelopeΣV\Sigma V86.3.920.923.3582.824.3.057n/a
Plateauδ=0.5\delta= 0.583.0.907.923.4013.530.2.05532.532.9
Plateauδ=1\delta= 184.3.912.919.3904.135.4.07131.532.2
Plateauδ=3\delta= 388.8+.936+.935.4103.125.3.06032.733.5
Linear78.5−.877−.881−.323−4.941.3.144−1.613.9
Calibratedper stage80.5.884−.894−.300−4.740.5.11362.260.0
Calibratedglobal81.5.895.898−.338−4.740.9.133−44.144.2
Learned add.α=0.5\alpha= 0.586.5.925.926.3722.823.3.04737.420.2
Learned add.α=0.8\alpha= 0.886.5.922.927.3533.227.3.06141.230.9
Learned add.α=0.95\alpha= 0.9587.8.927.927.3383.428.9.08544.039.3
Learned mult.α=0.5\alpha= 0.588.3.934.937.4322.621.2.03438.921.8
Learned mult.α=0.8\alpha= 0.885.3.915.923.3492.622.0.05541.531.1
Learned mult.α=0.95\alpha= 0.9587.3.926.921.3493.429.2.08344.739.5

Table 10. Funnel ablation on two-nut assembly, 400 episodes per configuration. Native: share of seated nuts. V-score: 1−V/V01-V/V_0. 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).

Representative refined and nominal episodes on two-nut assembly

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 VV 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 VV, which terminal contraction rejects, as a toppled tower does on stacking. The VV-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 CVaR90\mathrm{CVaR}_{90} and CVaR95\mathrm{CVaR}_{95} of the maximum drawdown, and in the CVaR10\mathrm{CVaR}_{10} of the final score. On PushT, every objective except the calibrated funnel lowers the drawdown CVaR90\mathrm{CVaR}_{90} significantly, by 6 to 10 points, and every one except the learned additive funnel at α=0.5\alpha= 0.5 also loses successes significantly, from 27 episodes for ΣV\Sigma V to 129 for the linear funnel. The learned additive funnel at α=0.5\alpha= 0.5 lowers the CVaR90\mathrm{CVaR}_{90} by 10.4 points and the CVaR95\mathrm{CVaR}_{95} 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 α=0.95\alpha= 0.95 lowers the drawdown tail significantly, by 5.7 points in CVaR90_{90} and 3.5 in CVaR95_{95}, 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 α=0.5\alpha= 0.5 and ΣV\Sigma V have the largest reductions of its CVaR90_{90}, 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 CVaR10_{10} of the final V-score significantly, and the linear funnel also loses 24 episodes. Among the configurations not shown, only the plateau at δ=3\delta= 3 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 CVaR90_{90}. 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 V˙≤0\dot{V} \le0 lie lowest between about 10 and 45 points, which is where their lower CVaR90_{90} 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 V˙≤0\dot{V} \le0 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 q=1%q = 1\%), 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 α=0.5\alpha= 0.5 and ΣV\Sigma V, 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 V0V_0 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 dd, as for PushT in Table 1 (right).

Figure 8. Two-nut assembly: share of episodes whose maximum V-score drawdown exceeds dd.

Figure 9. Mean maximum drawdown of the worst q%q\% of episodes, CVaR at tail fraction qq, for the objectives of Table 1; the dotted lines mark CVaR90\mathrm{CVaR}_{90} and CVaR95\mathrm{CVaR}_{95}. On two-nut assembly (c) the drawdown is that of the VV-score. In the legends, Endpoint is endpoint-only, Calibrated the calibrated global funnel and ΣV\Sigma V (MPC) the ΣV\Sigma V 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 α=0.95\alpha= 0.95 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 ϕ\phi of (23) with its finer lowering bands and alignment basin. The second builds both placements from the gate residual ϕg\phi^{g}, 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-ϕ\phi 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-ϕ\phi 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 ϕ\phi, so this coarser residual is sufficient on this task.

PotentialFixed funnelLearned funnelMeanMedianCVaR90_{90}
Nominal77.08.50.7546.1
Terminal tolerance63.050.013.46.442.9
Phased, gate residual ϕ\phi80.586.06.00.3143.0
Phased, residual ϕ\phi (main)74.582.37.00.5144.8

Table 11. Potential ablation on three-cube stacking, RMFM policy, with a fixed additive funnel and a learned additive funnel at α=0.95\alpha= 0.95 of matched size, on the 400 initial conditions and seeds of the main funnel ablation. The phased residual-ϕ\phi 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 wL=0.02w_L = 0.02 s on the physics-step grid of the rollout.

TaskFunnelExecutedNominal
SampledEstimatedEstimated
PushTPlateau, δ=0.5\delta= 0.573.373.348.7
Plateau, δ=1\delta= 168.968.845.8
Plateau, δ=3\delta= 369.069.046.2
Linear15.50.55.5
Calibrated, global71.260.515.4
Learned add., α=0.5\alpha= 0.544.138.07.5
Learned add., α=0.8\alpha= 0.864.256.218.6
Learned add., α=0.95\alpha= 0.9578.762.924.6
Learned mult., α=0.5\alpha= 0.542.640.512.2
Learned mult., α=0.8\alpha= 0.865.062.628.6
Learned mult., α=0.95\alpha= 0.9577.870.733.1
StackingPlateau, δ=0.5\delta= 0.541.941.940.0
Plateau, δ=1\delta= 140.940.935.4
Plateau, δ=3\delta= 340.640.635.4
Linear11.33.39.7
Calibrated, per stage84.157.647.2
Calibrated, global85.161.252.5
Learned add., α=0.5\alpha= 0.555.044.323.6
Learned add., α=0.8\alpha= 0.873.350.835.4
Learned add., α=0.95\alpha= 0.9581.154.341.9
Learned mult., α=0.5\alpha= 0.551.542.123.5
Learned mult., α=0.8\alpha= 0.871.049.234.2
Learned mult., α=0.95\alpha= 0.9581.654.243.6
Two-nut assemblyPlateau, δ=0.5\delta= 0.532.532.532.9
Plateau, δ=1\delta= 131.531.532.2
Plateau, δ=3\delta= 332.732.733.5
Linear14.21.613.9
Calibrated, per stage96.362.260.0
Calibrated, global97.144.144.2
Learned add., α=0.5\alpha= 0.567.237.420.2
Learned add., α=0.8\alpha= 0.877.741.230.9
Learned add., α=0.95\alpha= 0.9586.944.039.3
Learned mult., α=0.5\alpha= 0.559.638.921.8
Learned mult., α=0.8\alpha= 0.873.441.531.1
Learned mult., α=0.95\alpha= 0.9586.244.739.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 VV 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 δ=1\delta= 1 with η=0.1\eta= 0.1, γ=0.05\gamma= 0.05 and β=10\beta= 10 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-NN use the typical-set projection of § 4 unchanged. Every sampled seed is mapped by Ψ\Psi of (9), with one global group, before it is decoded, and the search mean is projected after each update. CEM, MPPI, best-of-NN and ours use ζ=4\zeta= 4, and two further configurations of ours use the tighter bands ζ∈{2,3}\zeta\in\{2,3\}. The sphere configuration fixes both radii of the band to the typical radius ν\sqrt{\nu} of (36), the projection of standardized CMA-ES (Stölzle et al., 2026). Best-of-NN 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 ζ=4\zeta= 4 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 ζ=2\zeta= 2 (+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-NN jumps significantly less (−0.049). At ζ=3\zeta= 3 the final score is slightly but significantly lower, in mean (−0.005) and CVaR10\mathrm{CVaR}_{10} (−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 (ζ=3\zeta= 3: [+5, +28]; ζ=2\zeta= 2: [+7, +28]), the sphere 38 ([+26, +50]) and best-of-NN 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-NN run 73 steps longer than ours ([+55, +90]) and those of the sphere 37 ([+18, +55]). Best-of-NN 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.

FunnelPushTStackingTwo-nut assembly
Nominal0.010.010.01
Endpoint-only1.173.846.18
No envelopeV˙≤0\dot{V} \le00.772.023.26
ΣV\Sigma V1.414.978.34
Plateauδ=0.5\delta= 0.51.063.936.11
δ=1\delta= 11.123.766.20
δ=3\delta= 31.144.096.79
Linear1.104.756.96
Calibratedper stage–3.384.53
global1.303.444.87
Learned add.α=0.5\alpha= 0.51.144.025.94
α=0.8\alpha= 0.81.023.805.75
α=0.95\alpha= 0.950.943.745.60
Learned mult.α=0.5\alpha= 0.51.173.905.84
α=0.8\alpha= 0.81.003.815.62
α=0.95\alpha= 0.950.993.815.56
Workers ×\times threads10 ×\times 414 ×\times 414 ×\times 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.

SearchTime [s]IterationsEvaluations
Nominal0.01–1
Adam†1.3320.321
L-BFGS†1.3514.536
Best-of-NN0.201200
CEM1.5240.4808
MPPI1.5242.0841
CMA-ES, no band1.5240.8815
CMA-ES, sphere1.5240.6811
Ours, ζ=2\zeta= 21.540800
Ours, ζ=3\zeta= 31.540800
Ours, ζ=4\zeta= 41.5240.3806

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, V˙≤0\dot{V} \le0 is the cheapest objective and ΣV\Sigma V 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-NN 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 VV, and the native task outcome improves when VV 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 ζ\zeta. 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. [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. [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. [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. [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. [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. [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. [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. [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. [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. [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. [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. [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. [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. [14]Stephen P. Boyd and Lieven Vandenberghe. Convex Optimization. Cambridge University Press, Cambridge, UK ; New York, 2004. doi: 10.1017/CBO9780511804441.DOI
  15. [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. [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. [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. [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
  19. [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
  20. [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
  21. [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
  22. [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
  23. [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
  24. [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
  25. [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
  26. [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.
  27. [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
  28. [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
  29. [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
  30. [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
  31. [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
  32. [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
  33. [34]Chandon Hamel. FlowMPC: Improving Flow Matching policies with World Models. arXiv preprint arXiv:2606.16286, June 2026.arxiv.org/abs/2606.16286
  34. [35]Nikolaus Hansen. The CMA Evolution Strategy: A Tutorial. arXiv preprint arXiv:1604.00772, March 2023.
  35. [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
  36. [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
  37. [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
  38. [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
  39. [40]Roger Koenker and Gilbert Bassett, Jr. Regression Quantiles. Econometrica, 46(1):33–50, 1978. doi: 10.2307/1913643.DOI
  40. [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
  41. [42]Scott Lembcke. Chipmunk2D: A fast and lightweight 2D physics library. https://codeberg.org/slembcke/Chipmunk2D, 2015.

Paper details

vlnc:W_rz599u8k
Version
v1 · latest
Published
Fresh — added to the Hub within the last 30 days
Added
License
CC BY 4.0
Usage

views · 2

downloads · 0

A view counts once per browser per day, a download each time the PDF is requested.

  • Computer Science

AI assistants

View statement
Looking for related papers…
Contents