WorksComputer Science
Certify, Then Select: Viability-Aware Runtime Steering of Frozen Diffusion Policies
Abstract
Diffusion policies, which generate short action sequences by denoising random noise, are a leading way to learn robot skills from demonstrations. Once deployed, they meet constraints the demonstrations never contained, and retraining for each is impractical. A safety filter edits the policy's action to satisfy them, but the edit ignores the task, and a large edit can leave the policy where it cannot continue. We propose CAST (Certified Action Selection at Test time): draw a few action chunks from the frozen policy, certify each with a barrier condition, and execute the certified chunk that a learned value ensemble ranks highest. We prove that a certified step is safe whatever the critic does; that, whenever a certified sample exists, the executed chunk stays within log N nats of the policy conditioned on feasibility, while a safety-filter projection can be singular to it; and that an exact closed-loop identity splits the gain of ranking into availability, spread and the critic's target. Certifying the next chunk is not enough: a generative controller can have safe actions available now and none later. We characterise the safe control authority of a frozen policy under finite sampling, and CAST-V preserves it through a policy-conditioned viability, estimated with a model under a finite-sample guarantee or learned from the controller's own logs (CAST-VL). On robomimic manipulation, a planar quadrotor, a MuJoCo humanoid and a unicycle, with frozen policies, CAST raises joint task-and-constraint success above the output filter in nearly every setting; certifying before ranking is decisive where a filter's edit is large, and viability removes most dead ends that one-step certification cannot see. Project page: https://clmoro.github.io/cast.
Introduction
Diffusion policies learn dexterous manipulation from demonstrations [9]. Once deployed, a policy meets constraints its demonstrations never contained: a person reaches across the table, a shelf is mounted above the workspace, the commanded effort must stay within a budget. Retraining for each is impractical. We want to enforce a constraint that arrives at run time, a request, on a policy that stays frozen.
The classical tool is a safety filter: take the action the policy proposes and edit it as little as needed for a certificate, such as a control barrier function, to hold [3, 34, 17]. Variants for diffusion policies apply the same edit inside the denoising loop [37, 28]. An edit answers the question “is this action safe?”. It does not ask whether the task can still be completed. A small edit leaves the policy as good or as bad as it was. A large one, as under an effort budget or when a zone blocks the policy’s route, leaves the robot where the policy has no data, and it stalls (Figure 1a). Neither helps the task: in our experiments no method that keeps the policy and has no critic reliably beats the plain output filter in joint task-and-request success (Table 1).
Figure 1. Edit or select. A keep-out zone, unseen in training, blocks one of the two routes of a frozen unicycle policy. (a) A safety filter keeps the robot in the safe set (shading: the barrier), but its rollouts on the blocked route stall at the zone: the policy never learned to continue from there (40 rollouts, with counts). (b) Viability of the policy’s certified chunks, by simulation: the probability that it keeps sampling certified chunks over the next 8 decisions. Certified chunks exist in the red region too, but lead to a dead end; of the drawn at one decision four head into it, and CAST-V executes a viable one. (c) The same map from a network trained on the controller’s logs, without model rollouts (CAST-VL): its boundary (black) follows the simulated one (white) where the rollouts pass. (d) Joint success on 500 unseen zones per policy; CAST, CAST-V and CAST-VL use the task critic, MPPI the model, map and goal.
| Method | R1 moving obstacle | R2 fast obstacle | R3 effort budget | R4 ceiling + wall | R5 pillar | max. viol. (%) |
| Frozen policy | 0.34 | 0.28 | 0.00 | 0.08 | 0.17 | 73.5 |
| Output filter (CBF-QP) | 0.61 | 0.49 | 0.37 | 0.47 | 0.53 | 2.5 |
| In-denoising projection | 0.60 | 0.51 | 0.39 | 0.45 | 0.52 | 1.0 |
| DPCC | 0.58 | 0.57 | 0.51 | 0.40 | 0.53 | 1.5 |
| Latent noise optimisation | 0.59 | 0.43 | 0.26 | 0.42 | 0.47 | 1.5 |
| Critic-free selection | 0.60 | 0.53 | 0.39 | 0.47 | 0.49 | 1.5 |
| Select-then-filter | 0.89 | 0.81 | 0.46 | 0.72 | 0.86 | 1.5 |
| CAST | 0.89 | 0.85 | 0.70 | 0.79 | 0.86 | 0.5 |
| CAST + guard | 0.90 | 0.86 | 0.70 | 0.80 | 0.89 | 0.5 |
Table 1. Robomimic Can, joint success under five requests (200 paired episodes each). Methods without a critic stay within 0.08 of the output filter except under R3; CAST adds 0.28–0.36 to it. The R3 filter caps every chunk; with CAST’s cap it reaches 0.46 on Figure 3b’s scenarios (CAST: 0.71).
© 2027 A. Moroncelli & L. Roveda.
A diffusion policy offers a resource that a deterministic controller lacks: for one observation it can propose many different, equally plausible actions. CAST (Certified Action Selection at Test time, Algorithm 1) uses this resource twice. It draws a few action chunks from the frozen policy, certifies each against the request, and executes the certified chunk that a value ensemble ranks highest. Only if no sample is certified does it fall back to the filter. The certificate provides safety, the critic provides task success, and whenever a certified sample exists the executed action is one the policy itself produced. But certification looks one step ahead, and a generative controller can have safe actions available today but lack safe behaviours tomorrow. Runtime constraint steering should preserve the learned policy’s future control authority, not merely certify its next action: CAST-V prefers chunks after which certified samples remain likely (Figure 1b).
Contributions
Method. CAST enforces a runtime request on a frozen diffusion policy by certifying sampled chunks and then ranking the certified ones (§ 4). It needs no retraining and one batched sampling pass per decision (15 ms on Can). Select-then-filter, which uses the same samples and critic but reverses the order, isolates the benefit of certifying before ranking.
Theory (§ 5; proofs in Appendix § 8). Four results say what each ingredient provides; the first three specialise known tools to sampling, certifying and selecting, and the fourth is the new object. Safety: a certified step is safe whatever the critic does, and one conformal calibration bounds the forecast risk for every controller (Theorem 1). Faithfulness: when a certified sample exists, selection stays within nats of the policy conditioned on feasibility, whereas a projection can leave its support (Theorem 2). Performance: an exact closed-loop identity says when ranking improves the task, through availability, spread and
the critic’s target (Theorem 3). Authority: the best any selection rule can do with samples to keep certified actions available grows with only up to what the policy samples with positive probability (Proposition 4); CAST-V and CAST-VL estimate it.
Evidence (§ 6). On robomimic, a quadrotor, a humanoid and a unicycle, with frozen policies and eight samples, CAST beats the output filter in nine of ten settings (Figure 5a; the tenth, a crossing pedestrian, is a tie). The critic supplies most of this gain; certifying before ranking adds to it where the edit is large (Can, : 0.53 against 0.16 for select-then-filter). Where a zone blocks a learned route, CAST-V restores availability (unicycle 0.99, against 0.81 for CAST), and CAST-VL does so from logs, without simulating continuations (quadrotor 0.98; MPPI 0.61).
Figure 5. Every setting at a glance. Paired differences in joint success with 95 % bootstrap intervals over shared scenarios. (a) CAST minus the output filter (for budgets: scaling the policy’s own chunk), task critic unless the setting has only a request-conditioned one. (b) CAST minus select-then-filter with the same samples and critic (pedestrian: the request-conditioned pair): certifying first adds where the filter’s edit is large (the budgets on Can and on the quadrotor) and is level or slightly behind elsewhere (small detours; mild scalings on Square and the humanoid). (c) CAST-V minus CAST with the same critic: large where a certified step can lead into a state from which the policy cannot continue (a blocked route, a crossing pedestrian, a fall under the humanoid’s budget), small under the quadrotor’s energy budget, level on Square and negative on Can’s new geometries and budgets, where CAST’s own choice is already viable and keeping options open costs progress. Pooled cells as in the main text and Table 2.
Related work. Safety filters correct a nominal input [3, 34, 17, 25, 25, 18]; shielding and sampling-based filters reject unsafe actions without a task model [2, 26]. Constrained diffusion edits the denoising iterates [37, 28, 13, 29] or the input noise [8]. Safety critics, recovery regions and viability can be learned from data [31, 32, 35] (Zheng et al. 2024), and planning over random action sets is classical [7]; CAST-V asks whether a fixed generative controller will keep sampling certified actions under a request it never saw. Sample-and-rank methods choose among policy samples by value [12, 24], density [30] or a verifier [20], without certificates. We analyse how sampling, rejection and ranking interact in frozen generative control, including when they cannot help, with information projection [11], performance differences [19] and conformal prediction [21, 10].
Problem
Policy. At decision a frozen generative policy maps the observation and a latent to a chunk of commands, whose first are executed in open loop; the law of is the policy , which we may sample but not change.
Requests. A request constrains a robot quantity (the hand position, or the speed) against a hazard with state : it holds at time if , where the barrier is 1-Lipschitz in each argument, as a signed distance is. A budget asks that the average command effort stay below : at every decision, with the effort of the executed chunks .
Certificate. A certificate provides a prediction of the robot (known or learned [23]) and a forecast of the hazard over the steps of the chunk and further steps of a backup that holds or brakes. A chunk is certified if
The margins and absorb predictor and forecast errors; with the barrier at the start of the chunk, with for (zero afterwards) is the discrete-time barrier condition [1]. For a budget, a chunk is certified if . We write for the set of certified chunks and for the feasible fraction: Algorithm 1: CAST, one decision. Inputs: observation , frozen policy , certificate, value ensemble , number of samples .
draw ; decode in one batch // sample
// certify
if then return , // select
else return the fallback: an output filter’s correction of a sample, or the backup
the probability that one sample of the policy is certified. When we argue with the closed-loop state we write , and . The goal is joint success: task completed, request kept at every step.
CAST: Certify, Then Select
Algorithm 1 is CAST; CAST-V changes only the select line. A correction need not end certified; the backup of the last certified chunk was certified with it (Proposition 6, Table 5).
| Controller | Fallback | per-step margins (Figure 11) Joint | per-step margins (Figure 11) Contact (%) | episode margins (Theorem 1(b)) Joint | episode margins (Theorem 1(b)) Contact (%) |
| Filter | edit | 0.72 | 1.5 | 0.61 | 0.9 |
| Filter | backup | 0.84 | 3.5 | 0.76 | 2.0 |
| CAST | edit | 0.73 | 2.4 | 0.60 | 0.7 |
| CAST | backup | 0.87 | 3.7 | 0.81 | 1.3 |
| CAST-V | edit | 0.82 | 1.0 | 0.91 | 0.0 |
| CAST-V | backup | 0.91 | 3.3 | 0.93 | 0.0 |
| CAST-VL | edit | 0.95 | 0.1 | 0.89 | 0.0 |
| CAST-VL | backup | 0.95 | 0.1 | 0.90 | 0.0 |
| CAST, log critic | edit | 0.98 | 0.1 | 0.93 | 0.1 |
| CAST, log critic | backup | 0.98 | 0.1 | 0.94 | 0.0 |
Table 5. The fallback, edit or certified backup, with the crossing pedestrian (three policies 500 shared scenarios, the controllers of Figure 11). “Edit”: the output filter’s correction, executed even if it does not end certified. “Backup”: instead, the rest of the braking backup certified with the last certified chunk (Proposition 6). Left: the per-step forecast margins of Figure 11; right: margins calibrated over whole episodes (), as Theorem 1(b) assumes. No contact began in a certified chunk in any of the 30 000 episodes. With edits, every contact began in an uncertified correction (76 of 76, per-step margins). With the backup and episode margins, no contact occurred during a certified step; all 50 came after the backup had brought the robot to rest. With per-step margins, which give no episode-level guarantee, 48 contacts fell inside the backup’s certified steps. Joint success with the backup minus with edits, episode margins: filter +0.15 [+0.11, +0.18], CAST +0.21 [+0.18, +0.24], CAST-V +0.02 [+0.01, +0.03].
Certify first. The certificate is checked before any value is consulted, so the critic never trades safety against task progress and ranks exactly the chunk that is executed. The opposite order, select-then-filter, edits the critic’s favourite and can execute a chunk the critic never scored.
A critic that needs no request. The ensemble ( small networks) regresses the discounted task success of the frozen policy’s rollouts, estimating , once and before any request is known. The unanimity guard variant keeps a certified unless every member prefers another.
A critic that knows the request. When a request changes which behaviour succeeds, as a zone blocking the preferred route does, we condition the critic on it: since the hazard ignores the robot, recorded frozen-policy rollouts can be relabelled with randomly drawn requests (success only if the request is kept from the current step on), with the request parameters as extra inputs.
Staying able to act (CAST-V). A certified chunk can lead to a state from which the frozen policy rarely samples a certified continuation, for example in front of a zone that blocks the route it has started. Define the viability of a certified chunk at state as the probability that, after , the critic-free certified controller with samples finds a certified sample at each of the next decisions, or reaches the goal first. CAST-V estimates it online by the fraction of model rollouts from the candidate’s end state that do so, executes the highest-value candidate with estimate at least , and the most viable one if there is none. No critic is retrained; the cost is up to extra samples per decision ( per continuation step; Table 3). Learned viability (CAST-VL) simulates nothing: its only model is the certificate’s one-chunk prediction. Each chunk in logs of the critic-free controller is labelled 1 if the next decisions all had a certified sample and nothing failed; an ensemble fitted to these labels replaces the rollouts.
| System | Controller | Policy samples | Model steps | ms | Joint success |
| Unicycle | CAST, | 8 | 96 | 1.7 | 0.81 |
| Select-then-filter | 8 | 12 | 1.5 | 0.86 | |
| MPPI (256 samples, horizon 20) | 0 | 5 120 | 0.9 | 0.91 | |
| CAST, | 256 | 3 072 | 33.0 | 0.37 | |
| CAST, | 1024 | 12 288 | 146.4 | 0.14 | |
| CAST-V, | 18.4 | 0.99 | |||
| CAST-VL | 8 | 96 | 1.7 | 0.95 | |
| Quadrotor | CAST, | 8 | 264 | 2.8 | 0.68 |
| Select-then-filter | 8 | 33 | 3.5 | 0.69 | |
| MPPI (512 samples, horizon 100) | 0 | 51 200 | 13.6 | 0.61 | |
| CAST, | 256 | 8 448 | 57.1 | 0.58 | |
| CAST, | 1024 | 33 792 | 231.0 | 0.55 | |
| CAST-V, | 135.7 | 0.93 | |||
| CAST-VL | 8 | 264 | 2.9 | 0.98 |
Table 3. Compute per decision on the zone tasks (task critic, mean of three policies). Policy samples and simulated model steps are per decision (CAST-V: worst case samples, certificate rollouts of every sample and simulated chunks; lazy search and early stops use fewer); ms: measured, one CPU thread, 500 episodes batched. CAST with and gives the plain selector about as many samples as CAST-V’s unicycle worst case; CAST-VL adds one network call to CAST.
Theory: What the Certificate, the Samples and the Critic Each Provide
Safety comes from the certificate, not from the critic
Assumption 1 (Prediction errors) On every executed step the robot is within of its prediction and the hazard within of its forecast: and for . The initial state is safe.
The forecast margins can be calibrated once, for a whole episode of at most decisions. Fix a miscoverage level and scales and score a recorded hazard episode by its largest normalised forecast error, . From calibration episodes take the -th smallest score and set .
Theorem 1 (Safety). (a) Under Assumption 1, the request holds on every step of every certified chunk that is executed, for any number of samples, any critic and any selection rule. (b) Suppose the initial state is safe, the hazard, its tracker and its forecaster do not depend on the robot, and calibration and deployment episodes are exchangeable. With the margins above, for every controller and jointly over calibration and deployment,
where is the event that at some executed step ; for a certified chunk the threshold is at least , so requires a prediction error above .
In words. (a) The critic can be arbitrarily wrong without making a certified step unsafe. (b) The hazard ignores the robot, so one calibration of the forecast serves a filter and CAST alike (Table 11); the robot’s own prediction error, , is not calibrated. With an exact predictor, the last certified chunk’s backup keeps a static request (Proposition 5) and, on the calibration event, a moving one through its steps (Proposition 6).
Table 11: Episode-level calibrated safety on Can (200 episodes per cell; CAST with the unanimity guard). : margin factor over the per-step 0.99 margins. †The per-step margins that apply after the first decision, the reference for .
| Margins | miscoverage offline, all decisions | miscoverage closed loop | collision | joint success | CAST − filter | ||
| 1.07 | 0.505 | 0.400 / 0.415 | 0.000 / 0.005 | 0.080 / 0.045 | 0.69 / 0.43 | +0.27 [+0.18,+0.34] | |
| 1.17 | 0.185 | 0.165 / 0.185 | 0.000 / 0.000 | 0.090 / 0.090 | 0.67 / 0.39 | +0.28 [+0.20,+0.36] | |
| 1.30 | 0.041 | 0.045 / 0.055 | 0.000 / 0.000 | 0.120 / 0.110 | 0.64 / 0.38 | +0.26 [+0.18,+0.34] | |
| per step 0.99† | 1.00 | 0.733 | 0.565 / 0.625 | 0.000 / 0.000 | 0.055 / 0.030 | 0.70 / 0.47 | +0.23 [+0.15,+0.31] |
Table 11. Episode-level calibrated safety on Can (200 episodes per cell; CAST with the unanimity guard). : margin factor over the per-step 0.99 margins. †The per-step margins that apply after the first decision, the reference for .
A certified sample stays close to the policy; a projection does not
Fix one decision and its state. Write for the certified set, for the feasible fraction, and for the policy conditioned on being certified. A batch of independent samples contains a certified one with probability , the availability.
Theorem 2 (Distance to the policy). (i) Among all action distributions that produce only certified chunks, is the unique closest to the policy in relative entropy, at distance . Executing the first certified sample of a batch, when there is one, draws exactly from . (ii) Let be the law of the chunk that CAST executes, given that the batch contains a certified sample, with any critic and any rule. Then
(iii) Suppose has a density and a filter maps a set of actions of positive probability onto a set of zero volume, as a projection onto the boundary of the certified set does. Then, with positive probability, the filter’s output lies in a set with : its law is not absolutely continuous with respect to , and its relative entropy to the policy is infinite.
In words. Enforcing a request costs at least ; selecting pays at most more, as in best-of- alignment ([5]), and executes a chunk the policy could have produced. A projection leaves the policy’s support, however small the edit; how much that matters depends on where the chunk lands (Proposition 4, § 6.3). Our fallbacks fall under (iii).
What ranking adds, and what limits it
Compare CAST with the same controller without a critic. Let be critic-free selection (execute the first certified sample) and be CAST; both use the same , certificate and fallback law on an empty batch. Let and denote their expected joint success over an episode of at most decisions, and the value of executing in state and following afterwards; here is the closed loop’s Markov state (robot, hazard, time, spent budget, memory, violation flag). At a state with batch , let be the indices of the certified samples and the chunk CAST executes, and define
both zero where .
Theorem 3 (Closed-loop gain of ranking) Let be the distribution of the state that CAST visits at decision . Then
With the variance of under ,
Suppose CAST executes the certified sample with the highest score , and there are an offset and a set of chunks with such that for every certified outside , for some target . Then
where is the largest minus the smallest value. A critic that is exact for gives .
In words: three levers. Ranking helps only if three things meet on the states CAST visits. Availability : a certified sample must exist. Spread : certified samples must differ in value; what ranking can gain grows at most as . A reliable critic for the right target: a task critic () suffices unless the request changes which certified samples succeed, as when a zone blocks the policy’s preferred route. The last term grows with : keep small for a weak critic.
Availability along the way. Certification constrains the next chunk only, so availability can be lost later: a certified chunk may lead to states where the policy rarely samples a certified continuation. Write for the (exact, deterministic) state transition of a chunk. If from every state of a set one sample is certified and leads back into with probability at least , a controller that executes such samples keeps one available for decisions except with probability (Proposition 7, Appendix § 8). Viability theory (Aubin, [4]) and reachability (Nakamura et al., [25]) compute viable sets from the dynamics alone; this one depends on the policy (Figure 8).

Figure 8. Safe set, feasible fraction and viability. Unicycle (Figure 1’s zone) and quadrotor (Figure 4a’s zone), on a slice of the state space (heading at the goal and cruise speed; level flight): (a) the CBF safe set that a filter protects, with ; (b) the feasible fraction , the share of 64 frozen-policy chunks the certificate accepts; (c) CAST-V’s viability estimate at the state, : the fraction of 16 critic-free certified continuations started at that find a certified sample at each of the next decisions (a chunk’s viability is at the state it leads to), its region (dashed) and 40 rollouts per controller with this zone fixed, as mean sd per route and outcome (filter: grey; CAST-V: dark blue; crosses: a group that stalls or crashes). States inside the safe set and with certified samples available can still be dead ends for this policy; the filter’s rollouts end there, CAST-V’s avoid them. Humanoid (effort budget 0.55; 16 scenarios): the certified region of the budget, torso height with the fall threshold, and distance walked; the filter rides the cap and falls in 15 of 16, CAST-V in 1. Illustration data, not scored.
A controller is selection-only with samples if at each decision it executes a certified one of fresh samples of , and fails if none is certified. Define the safe control authority of the frozen policy by and , the expectation over , with and at goal states, which are absorbing.
Proposition 4 (Finite-sampling generative control authority). Under the regularity conditions of Appendix § 8: (i) is the largest probability, over selection-only controllers with samples, that each of the first batches contains a certified sample or a goal state is reached first; executing at decision attains it. (ii) is nondecreasing in ; is the probability that the policy’s own samples are certified for decisions. (iii) As , , with if and only if : viability up to -null sets of chunks, and 0 wherever the certified chunks with form a -null set, even if such chunks exist.
In words. Safe control authority belongs to the dynamics, the request and the frozen policy with its samples: sampling helps up to -null sets and no further, and a filter reaches beyond them only by leaving the policy’s distribution (Theorem 2). CAST-V’s is the success probability of one selection-only controller from , so (estimation error: Proposition 8). The Bellman-style recursion follows established planning over random action sets ([7, 14]). Our contribution is its interpretation as the finite-sampling safe-control authority of a frozen generative policy.
Experiments
Setup. Systems: robomimic ([22]) Can with the state-based and camera-only diffusion policies released with DPPO ([27]), and Square with three diffusion policies trained on human demonstrations; a unicycle with known dynamics whose policies pass an obstacle above or below; a planar quadrotor and the MuJoCo humanoid, three policies each. Requests: a cylinder sweeping across the workspace; keep-out volumes; a budget on command effort. Baselines: the output filter (a CBF-QP on the chunk; scaling for a budget), projection inside the denoising loop ([37]), DPCC ([28]), noise optimisation ([8]), critic-free selection, select-then-filter, a predictive safety filter ([34]), and MPPI ([36]), which plans with the model, map and goal; all certified methods share the certificate, predictor and margins. Protocol: ; 200 episodes per manipulation cell, 500 per unicycle cell; brackets: paired bootstrap 95 % intervals.
CAST keeps the task while it enforces the request
Editing does not help the task; selecting does (Table 1; rollouts: Figure 6, Figure 7). The frozen Can policy ignores the request and violates it in up to 73.5 % of episodes. The output filter cuts violations to at most 2.5 % and reaches 0.37–0.61 joint success. The other methods without a critic land within 0.08 of it, except under the budget: they change how the constraint is met, not how well the task is done. CAST reaches 0.70–0.89 and violates in at most 0.5 % of episodes.
Figure 6. Rollouts in three simulators: edit (top) or select (bottom). Manipulation (robomimic Can, moving obstacle 0.10 m / 75, one scored scenario): rendered frames with the hand path, the virtual cylinder at four times (faded) and its barrier-gradient field projected into the camera; the output filter keeps the clearance but stalls until the time limit, CAST delivers the can. Quadrotor (no-fly zone unseen in training): the vehicle drawn to scale along its flight over the zone’s barrier field; the filter’s thrust corrections crash it, CAST (request-conditioned critic) executes a certified sample of the other learned route. Humanoid (effort budget , an illustration scenario): MuJoCo frames; scaling the torques to the cap makes it fall, CAST-V keeps walking within the budget. Arrows: , coloured by the barrier value (red: at the boundary; blue: far).

Figure 7. More rollouts: edit (upper row of each block) or select (lower row). Top, manipulation (rendered; the rendered episodes equal the scored ones). Can, keep-out pillar (+2 cm; red wireframe): the filter’s corrections keep the hand out of the pillar but it never transports the can; CAST carries it around. Can, effort budget : the filter caps every chunk and the hand stalls with the can; CAST executes certified low-effort chunks and delivers it. Square, moving obstacle (policy , cm): the filter’s fallback holds the nut near the obstacle until the time limit; CAST inserts it. Hand paths projected into the camera. Bottom, dynamic systems, drawn to scale from the recorded states: 40 rollouts per panel as mean sd per route and outcome (numbers: rollouts in the group; groups of one are not drawn; crosses: a group that stalls or crashes), one flight with the vehicle drawn. Unicycle and quadrotor no-fly zone: the zones of Figure 1 and Figure 4a fixed, CAST-V with the task critic. Quadrotor energy budget : the first 40 scored scenarios of policy , re-simulated for drawing (outcomes differ slightly from the scored run), CAST with the task critic; scaling the thrust to the cap costs altitude.
The gain holds on new requests and policies, fixed in advance and scored once (Figure 2). Over the filter, CAST gains +0.32 on six new Can geometries, +0.09 on Square (positive for each of three policies), +0.08 under Square effort budgets, and +0.10 and +0.08 [+0.03, +0.14] for a camera-only Can policy under R1 and under budgets. Every interval excludes zero (Figure 5a).
Figure 2. New requests, frozen models. Joint success on requests fixed in advance and evaluated once (right: the camera-only Can policy under R1 and two budgets, 0.20 and 0.30). Whiskers: 95 % intervals over shared scenarios. Select-then-filter and all other arms: Table 2.
Where the gain comes from. The critic avoids weak samples (best of eight without a request: 0.91 against 0.56), and shuffling its scores removes the gain (Can +0.32, +0.34; Square +0.16).
Certify first, or rank first? Select-then-filter has the same samples and critic. For obstacles and keep-out volumes, where its edit is a small detour, it is close to CAST (0.88 against 0.88 on the six new geometries; every setting: Figure 5b); there certifying first costs nothing and keeps Theorem 2’s guarantee. Under a budget the edit is large and the order decides: on the two new budgets CAST reaches 0.68 against 0.46 for select-then-filter (+0.22 [+0.16, +0.29]) and 0.42 for scaling. Square’s budgets cut its chunks less, and there ranking first does better (−0.04 [−0.07, −0.00] for CAST).
When does selection help? Moving the three levers
We move each lever on Can (Figure 3). A larger obstacle (a) blocks more of the workspace. CAST keeps +0.22 to +0.31 over the filter at every size, while DPCC and critic-free selection stay with the filter; select-then-filter is level for small obstacles and behind at 9 and 12 cm (+0.04 [+0.01, +0.08] for CAST). A tighter budget (b) makes the edit large. As it tightens, select-then-filter falls to plain scaling, whereas CAST executes a chunk that fits whenever one exists: at , 0.53 against 0.16 and 0.26; pooled over , +0.26. More samples (c): two already give 0.87 and four 0.89, but falls back to 0.77 (−0.10 from ): the critic’s own errors are selected, as the last term of (6) allows. The camera-only policy (d) gains most where the edit costs most (+0.22 at 9 cm), but its certified chunks are nearly interchangeable: under the state-based critic the best of eight is worth 0.013 more than their mean (0.051 for the state policy), so even that critic, reading the true object state, picks no better (0.75). Spread, not the critic, limits the gain. *When a lever is weak the gain vanishes: on robomimic Lift every certified controller reaches 0.94–0.97, and with a pillar in Square’s insertion path 55.7 % of batches are empty and random scores do as well (+0.03).
Figure 3. The levers of Theorem 3 on Can (200 shared scenarios per point; bands: 95 % intervals). (a) CAST keeps its lead as the obstacle grows. (b) Under a tight budget, ranking first falls to plain scaling. (c) Two to four samples give the whole gain; large batches lose part of it. (d) The camera-only policy: the lead holds at 9 cm, not at 12 cm.
Blocked routes: a critic that knows the request, or viability
When a request blocks the route a policy has committed to, one-step certification stalls, and looking ahead at the policy’s own samples fixes it without retraining. On the unicycle, a keep-out zone blocks one of two routes. The task critic cannot know it; once committed, the only certified chunks brake, and the robot stops short of the goal in 20 % of episodes with the filter and 15 % with CAST, while select-then-filter, whose edit slides along the zone, reaches 0.86 against 0.81. A predictive safety filter with a 20-step horizon stalls too (joint 0.75). Two remedies work on new zones of the family (Figure 1d). A critic that knows the request, trained once on zones drawn from a family, lifts CAST to 0.98, +0.16 over a matched task critic; with it, select-then-filter does as well (0.98). Viability needs no retraining at all: CAST-V, with the task critic and , reaches 0.99 and stalls in 0.4 % of episodes, beating CAST by +0.18 (Figure 5c) and select-then-filter with the same critic by +0.13. Viability alone does as well (0.99): future sample availability, not task value, decides. The lookahead matters (: 0.82, 0.83, 0.80), and little (Table 4); more samples do not replace it and select the critic’s errors (CAST with : 0.14; Table 3). Learned from logs (CAST-VL), viability reaches 0.95 (+0.14 over CAST), stays within 0.03 of model-based CAST-V when the actuators are 15–30 % weaker than modelled, and ranks never-executed candidates like the simulation (AUC 0.98 on the scored runs): future safe-control availability is learnable from interaction data (maps: Figure 1c, Figure 9). A success critic on the same 3000 logged episodes is slightly ahead (0.97; Table 4) but needs more of them: with 100, viability keeps 0.89 and the success critic 0.76 (Figure 10a). Both remove the lookahead, which costs CAST-V 10–50 times CAST’s decision time (Table 3). With a crossing pedestrian CAST-V gains +0.09 over CAST and matches MPPI; CAST-VL reaches 0.95 (Figure 11).
Figure 9. The boundary a frozen policy needs, simulated and learned. Four keep-out zones that the learned network never saw (unicycle, policy s0; the slice of the state space of Figure 8). Colour: mean viability of the policy’s certified chunks at each state (16 samples). The CBF boundary (red) is what a filter protects; the viability boundary lies far outside it and moves with the zone. Top: by simulation, as CAST-V estimates it. Bottom: from the network trained on logs of the critic-free controller (CAST-VL), with both boundaries. The two agree on 72–90% of about 42 000 certified chunks per zone (AUC 0.85–0.97); the learned map is softer inside the dead-end regions, which the logs rarely visit, and matches where the rollouts pass: CAST-VL reaches the goal in 37–39 of 40 rollouts. Illustration data, not scored.
Figure 10. Two diagnostics. (a) Viability or success as the learning target? Both networks are trained on the same logged episodes of the critic-free controller, with the same features, architecture and recipe; only the label differs (viability of the executed chunk, or the episode’s joint success). Unicycle, unseen zones, three policies 500 scored scenarios; bands: 95 % intervals, and at 100 episodes the range of three disjoint subsets, in each of which viability is ahead. With 300 episodes the two are level (+0.01 [−0.00, +0.03]), with 1000 the success critic is slightly ahead (−0.01 [−0.03, −0.00]), and with 3000 by 0.02. Viability is the cheaper label to learn and needs no task outcome; a success critic can replace it when logs are plentiful. (b) Where violations come from. Square, new requests, learned predictor (1 200 scored episodes per controller): share of violating episodes among those that executed at least one fallback chunk failing the certificate (an uncertified correction, or the hold backup, which is accepted without margins) and among those whose chunks were all certified. Theorem 1 covers the second group; none of its episodes violated.
Figure 11. A moving obstacle in space and time. Unicycle with a pedestrian crossing the corridor (random-walk speed 0.3–0.6 m/s, noisy tracker, constant-velocity forecast with per-step conformal margins at level 0.99). Left: three scored scenarios (policy s0) where the filter fails and CAST-V succeeds; the robot’s plane is the floor, time goes up, the pedestrian is a slanted tube and the central obstacle a vertical cylinder. The filter’s evasive corrections push the robot into the wall (scenarios 1 and 3) or into contact with the pedestrian (scenario 2); CAST-V passes ahead of the pedestrian. Right: joint success over three policies 500 shared scenarios. Critics trained on 6000 frozen-policy episodes per policy (task critic held-out 0.19–0.20; request-conditioned critic, which also sees the forecast, 0.68–0.71). CAST-VL: CAST-V’s rule with viability learned from 6000 logged episodes per policy of the critic-free certified controller (no crash or contact counts as viable; planned, scored once): 0.95, +0.23 [+0.19, +0.26] over the filter, +0.12 [+0.08, +0.15] over MPPI and +0.13 [+0.10, +0.16] over model-based CAST-V. A success critic trained on the same kind of logs lifts CAST itself to 0.98. Planned contrasts: CAST (request critic) − filter +0.024 [−0.018, +0.066], so with critics trained on frozen-policy episodes CAST alone does not beat the filter; CAST-V (task critic) − CAST (task critic) +0.093 [+0.071, +0.115]; CAST-V − MPPI −0.011 [−0.051, +0.028]. Also: CAST-V − filter +0.099 [+0.059, +0.139], − select-then-filter (request critic) +0.057 [+0.033, +0.082]. Pedestrian contact: 0.9–2.4 % for the certified controllers with frozen-policy critics (tracker noise), 0.1 % for CAST-VL and the log-trained critic, 0 for MPPI.
| CAST-V variant (default , , ) | Joint success | ms / decision |
| 0.823 [0.797, 0.848] | 6.0 | |
| 0.829 [0.804, 0.854] | 8.0 | |
| 0.803 [0.776, 0.830] | 13.3 | |
| (default) | 0.993 [0.988, 0.997] | 18.4 |
| 0.979 [0.970, 0.987] | 4.8 | |
| 0.971 [0.961, 0.981] | 7.7 | |
| 0.995 [0.990, 0.998] | 19.8 | |
| 0.995 [0.991, 0.999] | 33.9 | |
| 0.971 [0.961, 0.980] | 11.9 | |
| 0.995 [0.991, 0.999] | 12.2 | |
| viability only () | 0.991 [0.983, 0.997] | 21.3 |
| CAST-VL: viability learned from logs | 0.949 [0.934, 0.962] | CAST + 0.04 |
| success critic from the same logs (no viability) | 0.967 [0.956, 0.978] | CAST + 0.04 |
| CAST, task critic (reference) | 0.809 | 1.7 |
Table 4. CAST-V ablation on the unicycle’s unseen zones (task critic, three policies 500 shared scenarios): lookahead , continuations , threshold , viability alone, CAST-VL and a success critic trained on the same logs (network cost on top of CAST). Viability is nearly always close to 0 or 1, so even separates the candidates; must cover the time to commit to a route.
Dynamic systems: a quadrotor and a humanoid
A quadrotor couples translation and rotation, so an edited thrust command changes the rest of the flight (Figure 4). No-fly zones. On zones unseen in training, the output filter never enters the zone but crashes the vehicle in 56 % of episodes, reaching 0.44; MPPI with model, map and goal reaches 0.61. CAST with the task critic reaches 0.68; CAST-V with the same critic and reaches 0.93 (+0.25 over CAST), and the request-conditioned critic 1.00. CAST-VL, with no model rollouts, beats model-based CAST-V (0.98). Energy budget. The filter scales the thrust down and the vehicle sinks. Pooled over the four budgets 1.015–1.03, CAST beats select-then-filter by +0.09 and the filter by +0.36; CAST-V adds +0.02. Humanoid. Under an effort budget the filter scales the torques and the humanoid falls in 74 % of episodes. CAST gains +0.53 over the filter over four budgets. Select-then-filter does as well: a small scaling keeps the gait. CAST-V beats both (+0.09 over CAST).
Figure 4. Dynamic systems, three frozen policies each. (a) The filter’s thrust edits keep a no-fly zone but crash the vehicle; CAST (request-conditioned critic) takes the other route. (b) Unseen zones, 500 scenarios per policy (“req.”: request-conditioned critic). (c) Quadrotor energy budget; at almost no chunk fits and scaling does better. (d) Humanoid effort budget, 300 scenarios per policy (shaded: added later). 95 % intervals.
Safety. With exact models no violation began in a certified chunk; with a learned predictor violations came with the fallback: every violating Square episode of CAST executed a fallback chunk that failed the certificate, and the 554 whose chunks were all certified had none (Figure 10b). A certified backup aligns the controller with the theorem. With the pedestrian, executing the last certified chunk’s braking backup instead of an uncertified correction, and calibrating the forecast over whole episodes as Theorem 1(b) assumes, no contact occurred during a certified step. Contacts did not fall, but all 50 came after the robot had stopped, which is passive safety ([6]); see Proposition 6. Failures more than halved: CAST rose from 0.60 to 0.81 (Table 5).
Conclusion
A frozen diffusion policy can respect a runtime constraint by sampling a few chunks, certifying them, and letting a critic choose: the certificate gives safety, the critic task success. Certifying first matters when a filter’s edit is large; viability matters because the physical capacity to act safely and a frozen policy’s capacity to sample safe actions differ, and finite sampling makes the difference decisive. Limitations. Selection cannot create behaviour the policy never samples or help a policy that already succeeds; where an edit is benign, ranking first does as well or better; CAST-V costs progress where CAST’s choice is already viable. Safety is passive, for hazards that ignore the robot: it covers certified chunks and their backup, not a hazard reaching a robot at rest; tests are simulated.
Generative AI use. Claude (Anthropic) assisted with code, experiments, writing, and literature search; the authors are responsible for the manuscript.
Proofs
Theorem 1(a). For , by the Lipschitz property of , Assumption 1 and (1),
Every control step after belongs to one executed chunk, and nothing in the argument involves how the executed chunk was chosen. For the budget, induction on keeps the budget; the cap is at least , and for an effort that is continuous and zero at the zero command, as ours is, a sufficiently scaled chunk satisfies it.
Theorem 1(b). Write for the hazard trajectory and the tracker noise. By assumption the law of is the same under every controller, and the forecasts are fixed functions of . The score therefore has the same law under every controller. The calibration episodes and the deployment episode are exchangeable, and makes the index at most , so (Vovk et al. [33]), jointly over calibration and deployment. On , for every executed step ,
which is non-negative unless occurs; the initial state is safe. Hence . If the executed chunk is certified, , so needs a prediction error above . For a chunk that is not certified the slack can be negative and the bound is void.
Proposition 5 (Recursive feasibility). Let the request be static and the predictor exact (), and let the backup be a fixed feedback law that reaches rest within steps and is safe from the initial state. If the controller executes certified chunks, and the backup when there is none, the request holds at every step and the backup stays safe at every decision.
Proposition 5. Induction hypothesis at decision : the backup path from keeps (true at by assumption). Case (i): a certified chunk is executed. The predictor is exact, so its steps and the backup steps after it keep , and the backup is at rest at the end, where a static no longer changes. Case (ii): no chunk is certified and the backup is executed; its path is safe by the hypothesis. In both cases the backup path from is the remainder of a safe path that ends at rest, so the hypothesis holds at . The statement does not cover a controller that executes an uncertified correction instead of the backup.
:::
Proposition 6 (Backup against a moving hazard). Under the assumptions and margins of Theorem 1(b), let the robot predictor be exact (), the robot start at rest in a safe state, and the backup an open-loop law that every certificate (1) checks for the steps after its chunk and that brings the robot to rest within steps. Suppose the controller executes a certified chunk whenever there is one and otherwise the next steps of the backup that followed the last certified chunk. Then, on the calibration event of probability at least , the request holds at every step of every certified chunk and at each backup step executed within steps after it: a violation can occur only before the first certified chunk or after consecutive backup steps, with the robot at rest in both cases (passive motion safety in the sense of Bouraine et al. [6]).
Proposition 6. Fix a decision at which a certified chunk is executed. On the event, for every , because is a maximum over all and . The certificate gives for , where for is the predicted backup. If the following decisions have no certified chunk (sample or correction), the controller executes the continuation of that same backup, so with an exact predictor the executed positions are for , and by the Lipschitz property . A new certified chunk restarts the argument at its own decision. Every step is therefore covered until backup steps have been executed in a row, after which the robot is at rest and no certificate makes a claim about a hazard that then reaches it.
Theorem 2. (i) For with , , so
which is minimised uniquely at ; if the divergence is infinite. The samples are independent draws from at the fixed state, so the first certified sample in draw order has law .
(ii) The lower bound is (i), since . For the upper bound, the executed chunk is one of the certified samples, so for every measurable ,
Hence and ; insert this in (7). Finally gives . (iii) Let be the zero-volume image set. because has a density, while the filter’s output lies in with positive probability; a law that charges a -null set has infinite relative entropy to .
Theorem 3. Identity. All values use the same reward (joint success) and the same Markov state; terminal states are absorbing and the horizon is . Telescoping along the trajectories of gives the performance-difference identity (Kakade and Langford, [19])
At one state, couple and on the same batch and the same fallback randomness; only their action marginals enter the identity, so the coupling costs nothing. On an empty batch both execute the shared fallback and the difference vanishes. On a non-empty batch let . The critic-free action is the first certified draw, with conditional law . Therefore
and because the first certified sample has law .
Ceiling. Conditional on the number of certified samples, their chunks are independent draws from . Let be the quantile function of under , with mean and variance . The maximum of independent uniforms has density , so by Cauchy–Schwarz
the classical bound on the expected maximum ([16, 15]). Averaging over with Jensen’s inequality,
The last expression increases with and equals at .
Ranking loss. Let be the event that no certified sample of the batch lies in the exceptional set ; given certified samples, which are independent draws from , . On , let maximise and let maximise among the certified samples. Then
where the first bound uses and (the offset cancels). Off the loss is at most one, because values are success probabilities. Taking the conditional expectation gives (6). With the oscillation vanishes, and with the identity (4) gives . The bound is for the maximiser of one score; it does not cover the unanimity guard.
Proposition 7 (Generative viability) Let for a set of states, with exact and deterministic and batches drawn afresh at each decision. Suppose and for every . If a controller executes, whenever its batch contains one, a certified sample that leads into , then the probability that some batch among the first decisions contains no such sample is at most ; on the complementary event every executed chunk is certified and the state stays in .
Proposition 7. Let be the event that the batch at decision contains no certified sample leading into . On every executed chunk was certified and led into , so . Given , the samples are independent draws from , each certified and leading into with probability , so . Hence .
Proposition 4. Hypotheses: standard Borel state and action spaces, a stochastic kernel, deterministic and measurable, measurable in ; batches are drawn afresh at each decision, independently of the past given the current state; goal states are absorbing. With a stochastic exogenous hazard, (i) and (ii) hold with replaced by its expectation over the hazard’s transition; (iii) needs the deterministic . A selection-only controller may use the whole history and its own randomisation, independent of future batches given the current state. (i) By induction on ; is trivial. Fix any selection-only controller and condition on the history and on the first batch . If no sample is certified the controller has failed. Otherwise it executes some certified , possibly at random, and from it continues as a selection-only controller whose history is extra randomisation independent of the future batches; by the induction hypothesis it keeps a certified sample in each of the next batches, or reaches a goal state first, with probability at most . Taking expectations over the batch gives at most . The greedy rule, over certified samples with ties to the smallest index, attains each inequality, so it attains (the arg max over finitely many samples is measurable). (ii) By induction, , and a maximum over samples dominates the maximum over
the first , which are independent samples; so . With the only choice is the single sample, executed if certified. (iii) Write and for the same with . For a bounded measurable , almost surely, hence in expectation. Assume, inductively, pointwise. Upper bound: . Lower bound: for , , and because pointwise (for the set has positive mass, and by continuity of measure so does for large $N_0). So , which is -valued by induction and equals $1$ exactly when . The classical indicator if and only if some admissible has ; a set of positive -mass is nonempty, so by induction , with strict inequality exactly where but the certified chunks with form a -null set. The same induction shows that a controller whose action law is absolutely continuous with respect to at every state survives decisions with probability from any with . Finally, CAST-V’s critic-free controller is selection-only with samples, so (i) gives .
Estimated viability. With exact and deterministic, let be the probability that the critic-free certified controller ( samples per decision, same certificate) from finds a certified sample at each of the next decisions, or reaches the goal first, without task failure, and .
Proposition 8 (Estimated viability). With continuations on fresh latents and threshold , CAST-V executes a certified chunk with except with probability at most , with (two binomial tails, below) , after which its next batch is empty with probability at most . If at every decision before the first failure, an empty batch or a chunk with occurs within decisions with probability at most .
In words. Policy, estimate and lookahead width each add a term. Our leaves loose ( for ), but CAST-V executed a chunk of viability below when one above existed at of decisions (below). The episode bound is vacuous at our (); it shows how the risk falls with and .
Proposition 8. Hypotheses: is exact and deterministic, each continuation draws fresh latents, and continuations use the same certificate. Exactly, with . Fix the batch at . With an exact model, the continuations of a candidate use fresh latents, so its estimate is the mean of independent Bernoulli() variables given the batch; CAST-V accepts if , i.e. if at least continuations are viable, and executes the highest-ranked accepted certified candidate (lazy evaluation in critic order stops at exactly this candidate), or the most viable one if none is accepted. Selection. Let be the event that no batch member is certified with ; . On pick such a member . Its estimate falls below with probability , since the binomial upper tail increases with the success probability. Otherwise the accepted set is non-empty and the executed chunk is accepted; it has only if some candidate with is accepted, which by a union bound over at most candidates has probability at most . Hoeffding’s inequality bounds both tails by the exponentials. Transfer. Let and . If ends the task there is no next batch. Otherwise a continuation is viable only if its first batch of samples contains a certified one, so . CAST-V’s next batch consists of independent draws at , so it is empty with probability .
Horizon. At decision let be the event that the batch has no certified member with , or the executed chunk has , or the next batch is empty after a chunk with . Conditionally on the past and , ; the first batch is empty only on ’s first part, and every later empty batch or low-viability chunk lies in some . A union bound over with gives the claim. Nothing is assumed about the critic. □
Measured (unicycle, three policies 500 scored scenarios, CAST-V with ; reference viability of every certified candidate from 64 further continuations, not used to act; its decisions are identical to the scored cells). Decisions with a certified candidate of reference viability : 16 901; the executed chunk had reference viability below 0.1 in 0.07 % of them (bound ). For : 0.26 % of 17 057 (bound vacuous, 2.14). Only 4.96 % of 140 200 certified candidates have reference viability between 0.1 and 0.9: viability is nearly always close to 0 or 1, where suffices.
An exact critic with the wrong target can fail. Consider two certified chunks that commit to different routes; the policy samples route A with probability and route B otherwise. On route A the continuation completes the task safely with probability . On route B the frozen policy completes the task with probability one, but only by crossing a keep-out zone later; no certified continuation completes route B. The task values are and , whereas the values under the request are and . An exact task critic selects B whenever a B sample appears, so , below the critic-free value for every . Both first chunks pass the certificate; the failure is in their continuation. On a batch that contains both routes the oscillation term of (6) equals one, and the identity (4) returns exactly . A critic trained on success under the request ranks A first and attains .
Experimental details
Robomimic Can. Policy: the diffusion policy released with DPPO [27] (MLP denoiser, 20 DDIM steps, chunks of four 7-dimensional commands at 20 Hz, at most 300 control steps). It completes the task in 0.560 of episodes without any request. Critic: five MLPs on (state, chunk) regressing Monte Carlo task success with discount 0.99 on 2000 rollouts of the frozen policy. Hand predictor: linear in the chunk’s cumulative commands and the previous chunk, fitted by least squares on 2000 episodes; cm. Requests of Table 1: R1, a vertical cylinder of radius 6 cm that sweeps the transport corridor sinusoidally (amplitude 0.15 m, period 100 steps, random phase); R2, the same cylinder faster than the hand can move (amplitude 0.18 m, period 50); R3, a budget on the mean squared position command; R4, a ceiling and a workspace wall; R5, a non-convex keep-out pillar. The obstacle is observed at the current and previous step and extrapolated at constant velocity; no controller sees its future. For R1, the new obstacle requests and the sweeps the certificate uses and : it checks the predicted clearance of the four steps of the chunk, with no rate term and no backup steps. R2 uses , and conformal forecast margins. When no sample is certified, the obstacle and keep-out controllers apply the output filter (at most four relinearised projections, which need not end certified) to a sample; the budget controllers scale the sample of least effort to the cap. New requests of Figure 2: obstacle amplitudes m with periods , the pillar shifted by cm, and budgets 0.20 and 0.30. The camera-only policy is DPPO’s image policy; its critic reads the policy’s own 137-dimensional embedding.
Robomimic Square. Three diffusion policies (seeds of one recipe) trained on the proficient-human demonstrations: 1-D convolutional U-Net, 16 DDIM steps, chunks of sixteen commands of which eight are executed. Each policy has its own critic and hand predictor, fitted on 2000 of its rollouts; cm, the 95th percentile of the predictor’s error. Request: a cylinder of radius 6 cm moving across the path to the peg (amplitude 0.15 m, period 100), forecast with constant acceleration, at its original position and shifted by cm.
Unicycle. State , time step 0.1 s, bounded acceleration and turn rate, known exactly to every controller. The robot crosses a corridor () around a disc obstacle (centre , radius 0.4) to a goal region within 120 steps. The diffusion policy (MLP, 10 DDIM steps, chunks of four controls) is trained on 3000 demonstrations that pass above or below the obstacle and succeeds in 0.98 of episodes without a request. Request: a keep-out disc of radius 0.3 on one side. In the family study its centre is drawn per episode from , . The request-conditioned critic has the architecture of the task critic plus five inputs (zone position relative to the robot, side, current barrier value, time). For each of three policies it is trained on 20 000 frozen-policy rollouts labelled with zones drawn from the family; the matched task-target critic uses the same rollouts, inputs, initialisation and optimiser, and only the label differs. Evaluation zones are drawn independently. Certified controllers share an 8-step braking backup and . MPPI (256 samples, horizon 20 steps of the 120) and its hard-constrained variant (same horizon; candidates must pass the certificate) know the dynamics, the map, the goal and the zone, and do not use the policy; they are short-horizon references, not upper bounds. The extra latents of a batch are drawn from a separately seeded generator, so every batch holds independent samples, as the theory assumes.
Planar quadrotor. State at 50 Hz with collective thrust and torque ; known exactly to every controller. Task: from the left to a goal box within 8 s, without touching floor, ceiling or a central disc obstacle. Three diffusion policies (MLP, 10 DDIM steps, chunks of eight controls) are trained on 3000 expert demonstrations each, half above and half below the obstacle; task critics (held-out 0.51–0.63) and request-conditioned critics (held-out AUC 0.99) use 4000 frozen-policy rollouts, each labelled with four zones from the family. Certificate: the chunk and a 25-step brake-to-hover backup, rolled out with the exact model, ; budget: exact prefix inequality on . The output filter is the minimal-norm correction (finite-difference linearisation, three relinearisation[s]; for the budget, thrust scaling), shared as the
fallback. MPPI: 512 samples, horizon 2 s, soft request penalties, and the shared certificate on what it executes; without a request it succeeds in 0.69 of development episodes. The budget levels and the planner horizon were chosen on development scenarios disjoint from the scored ones.
Humanoid. Gymnasium Humanoid-v5 (MuJoCo, 17 actuators, 15 ms control step). Three diffusion policies (MLP , 10 DDIM steps, single-action chunks, full 348-dimensional observation) are trained on 2M pairs from Farama Minari’s humanoid expert-v0 and medium-v0 demonstrations (SAC rollouts), 80k steps on one GPU (75 s per policy). Success: no fall (the environment’s healthy-height termination) within 300 steps and at least 1 m forward. Critics: five MLPs on (observation, action), discounted success (0.995 per step) from 1500 frozen-policy rollouts per policy (held-out 0.70–0.76). Budget: per step on actions normalised to , prefix average at most ; the filter scales the policy’s own action to the cap, the selectors’ fallback scales the least-effort sample.
CAST-V. Viability is estimated with continuations of the critic-free certified controller from each certified candidate’s end state ( policy samples per step, exact model, the request’s certificate); a continuation is viable if it finds a certified sample at each of the next decisions without a task failure, or reaches the goal. ; unicycle (3.2 s), quadrotor (2.6 s), humanoid steps (0.3 s; a fall in a continuation is not viable). Candidates are evaluated lazily in critic order (the first with is executed; same choice as evaluating all). Robomimic. The model is a shadow copy of the simulator restored to the current state (MuJoCo state, clock, controller goals and gripper ramp), which a real robot would not have; decisions on Can and on Square (32 steps each); a moving obstacle is forecast at constant velocity from its positions at the real decision, so the exact-model hypothesis of Proposition 8 does not hold there. Fidelity of the shadow after one chunk (normalised hand and can position): median 0.003–0.005, maximum 0.04–0.06. With the controller reproduced CAST’s saved episodes exactly on one 50-episode block of each request and on Square. CAST-V overrode CAST’s choice at 2–5% of decisions on obstacles and Square and 14–20% on pillars and budgets; it cost about 35 s per Can episode and 20 s per Square episode on one CPU thread (CAST: about 2 s).
Baselines. Output filter: minimal-norm correction of the policy’s chunk onto the linearised certificate, solved as an exact dual QP with relinearisation (a CBF-QP on the chunk). For budgets there are two scaling filters: one caps the effort of every chunk at (Table 1, R3; “chunk cap” in Table 9), a stricter rule than the average budget; the other scales the policy’s chunk only as far as the average budget requires, which is CAST with and the like-for-like baseline of Figure 2 and Figure 3b. In-denoising projection: the same projection applied to the denoised estimate at every DDIM step, in the manner of SafeDiffuser (Xiao et al., [37]). DPCC (Römer et al., [28]): our port projects every reverse iterate onto the tightened constraint for chains started from the latents CAST draws and executes the chain with the smallest cumulative projection. Noise optimisation, in the manner of INSPO (Chen et al., [8]): Adam steps on the latent against the predicted violation, through the differentiable sampler. Critic-free selection: CAST without the critic. Select-then-filter: the sample with the highest value, then the output filter. All arms of a comparison use the same predictor and margins and, where they sample, the same latents; the sampling controllers also share the fallback.
Table 9: Can sweeps behind Figure 3: joint success, 200 shared scenarios per cell; ( %) marks violation rates of at least 0.5 %; at 9 and 12 cm every controller violates, as empty batches become frequent (Safety paragraph of § 6.4). “Chunk cap” caps every chunk; “scaling” is CAST with . The guard column of the sample sweep, the scaling column and the last row were added after the planned run (best of eight without a request: 0.905 on the scenarios of the ranking intervention).
| Obstacle radius (cm) | frozen | filter | DPCC | critic-free | sel.-then-filter | CAST | CAST + guard |
| 3 | 0.46 (v18) | 0.56 (v1) | 0.56 | 0.55 | 0.87 | 0.86 | 0.92 |
| 6 | 0.34 (v35) | 0.56 (v2) | 0.58 (v0.5) | 0.57 (v1) | 0.85 | 0.87 | 0.90 (v2) |
| 9 | 0.24 (v52) | 0.50 (v6) | 0.52 (v8) | 0.53 (v6) | 0.78 (v6) | 0.81 (v6) | 0.83 (v6) |
| 12 | 0.11 (v76) | 0.34 (v30) | 0.36 (v32) | 0.34 (v31) | 0.51 (v32) | 0.55 (v32) | 0.58 (v30) |
| Effort budget | chunk cap | scaling | critic-free | sel.-then-scale | CAST | CAST + guard | |
| 0.10 | 0.09 | 0.10 | 0.08 | 0.07 | 0.28 | 0.27 | |
| 0.15 | 0.23 | 0.26 | 0.19 | 0.16 | 0.53 | 0.53 | |
| 0.20 | 0.29 | 0.32 | 0.23 | 0.31 | 0.64 | 0.67 | |
| 0.25 | 0.37 | 0.46 | 0.35 | 0.43 | 0.71 | 0.68 | |
| 0.30 | 0.41 | 0.45 | 0.44 | 0.63 | 0.73 | 0.79 | |
| 0.40 | 0.42 | 0.51 | 0.47 | 0.77 | 0.84 | 0.81 | |
| 0.60 | 0.53 | 0.52 | 0.54 | 0.87 | 0.88 | 0.91 | |
| Samples (obstacle 6 cm / budget 0.25) | critic-free | sel.-then-filter | CAST | CAST + guard | |||
| 1 | 0.56 / 0.46 | 0.56 / 0.46 | 0.56 / 0.46 | 0.56 / 0.46 | |||
| 2 | 0.56 / 0.39 | 0.85 / 0.70 | 0.87 / 0.66 | 0.83 / 0.60 | |||
| 4 | 0.56 / 0.38 | 0.90 / 0.69 | 0.89 / 0.75 | 0.90 / 0.71 | |||
| 8 | 0.57 / 0.35 | 0.85 / 0.43 | 0.87 / 0.71 | 0.90 / 0.68 | |||
| 16 | 0.56 / 0.33 | 0.80 / 0.41 | 0.80 / 0.68 | 0.86 / 0.67 | |||
| 32 | 0.57 / 0.29 | 0.74 / 0.35 | 0.77 / 0.66 | 0.78 / 0.60 | |||
| No request, critic’s best of samples, : 0.56, 0.87, 0.91, 0.86, 0.80, 0.77 |
Table 9.
Protocol. Unless stated, ; 200 episodes per manipulation cell and 500 per unicycle cell; all arms of a comparison run on the same scenarios, with paired bootstrap 95 % intervals. The policy, critic and predictor are fixed before the evaluation scenarios are drawn. For four studies the design, scenario seeds and planned comparisons were fixed before any scored episode was run: the new requests (Figure 2), the ranking intervention, the Can sweeps (Figure 3) and the zone family
(Figure 1d). The later studies also had their plans fixed before scoring, except the ablation, the humanoid’s two tightest budgets, the cells that complete Table 2 and the violation breakdown of Figure 10b. On the new Can and Square requests the planned primary arm was CAST with the guard; plain CAST, reported in the text, was secondary. Not every planned threshold was met: the budget gains on Square and with the camera-only policy were +0.08 against a planned +0.10, and CAST-V did not improve on CAST in manipulation (Figure 5c). Simulations ran in Docker on one workstation (crossing pedestrian and CAST-V ablation: a laptop CPU); a decision of CAST with the guard takes 15 ms on two CPU threads.
| Cell | Frozen | Filter | Crit.-free | Sel.-filter | CAST | + guard | CAST-V |
| Can, obst. 0.10 m / 75 | 0.27 | 0.58 | 0.58 | 0.89 | 0.91 | 0.92 | 0.89 |
| Can, obst. 0.10 m / 125 | 0.28 | 0.56 | 0.54 | 0.89 | 0.89 | 0.90 | 0.90 |
| Can, obst. 0.20 m / 75 | 0.38 | 0.56 | 0.56 | 0.83 | 0.85 | 0.90 | 0.83 |
| Can, obst. 0.20 m / 125 | 0.36 | 0.58 | 0.56 | 0.88 | 0.90 | 0.92 | 0.88 |
| Can, pillar +2 cm | 0.17 | 0.54 | 0.57 | 0.88 | 0.88 | 0.91 | 0.77 |
| Can, pillar −2 cm | 0.18 | 0.55 | 0.58 | 0.91 | 0.88 | 0.91 | 0.77 |
| Can, budget 0.20 | 0.00 | 0.34 | 0.31 | 0.30 | 0.64 | 0.55 | 0.43 |
| Can, budget 0.30 | 0.00 | 0.50 | 0.43 | 0.61 | 0.72 | 0.78 | 0.69 |
| Square, s0, −2 cm | 0.47 | 0.70 | 0.66 | 0.81 | 0.83 | 0.77 | 0.81 |
| Square, s0, +2 cm | 0.51 | 0.70 | 0.70 | 0.71 | 0.76 | 0.81 | 0.77 |
| Square, s1, −2 cm | 0.44 | 0.68 | 0.69 | 0.76 | 0.74 | 0.72 | 0.75 |
| Square, s1, +2 cm | 0.49 | 0.69 | 0.68 | 0.76 | 0.74 | 0.71 | 0.77 |
| Square, s2, −2 cm | 0.45 | 0.71 | 0.71 | 0.82 | 0.81 | 0.78 | 0.80 |
| Square, s2, +2 cm | 0.46 | 0.70 | 0.70 | 0.78 | 0.81 | 0.79 | 0.80 |
| Square, budget 0.25 | 0.00 | 0.55 | 0.54 | 0.65 | 0.62 | 0.60 | 0.61 |
| Square, budget 0.30 | 0.00 | 0.63 | 0.62 | 0.76 | 0.72 | 0.68 | 0.71 |
| Camera, R1 | 0.47 | 0.62 | 0.62 | 0.73 | 0.73 | 0.74 | 0.73 |
| Camera, obstacle 9 cm | 0.31 | 0.43 | 0.47 | 0.65 | 0.66 | 0.57 | 0.66 |
| Camera, obstacle 12 cm | 0.14 | 0.33 | 0.32 | 0.41 | 0.36 | 0.37 | 0.40 |
| Camera, budget 0.15 | 0.00 | 0.27 | 0.29 | 0.30 | 0.34 | 0.37 | – |
| Camera, budgets 0.20/0.30 | 0.03 | 0.47 | 0.46 | 0.51 | 0.55 | 0.54 | – |
| Camera, | 0.42 | 0.55 | 0.60 | 0.66 | 0.72 | 0.66 | 0.78 |
| Camera, , budgets 0.20/0.30 | 0.04 | 0.47 | 0.42 | 0.59 | 0.56 | 0.56 | – |
Table 2. Every arm in every cell of Figure 2, with further camera-only cells (9 and 12 cm: Figure 3d; : scale of the policy’s initial denoising noise, elsewhere) (joint success; 200 shared scenarios per cell; – not run). Frozen: the policy’s own sample, ignoring the request. For budgets, “Filter” scales the policy’s own chunk to the cap (CAST with ; the per-chunk cap filter: Table 9) and select-then-filter selects, then scales.
Additional tables. Table 2–Table 5 give the cells of Figure 2, the compute, the CAST-V ablation and the fallback study; Table 6–Table 10 give the quadrotor, humanoid, unicycle, Can-sweep and CAST-VL cells; Table 11 gives the calibration check.
| Budget | filter | critic-free | sel.-then-filter | CAST | CAST + guard | shuffled | CAST-V |
| 1.01 | 0.17 | 0.02 | 0.11 | 0.00 | 0.00 | 0.03 | 0.01 |
| 1.015 | 0.58 | 0.62 | 0.71 | 0.83 | 0.74 | 0.61 | 0.89 |
| 1.02 | 0.59 | 0.77 | 0.83 | 0.97 | 0.96 | 0.74 | 0.99 |
| 1.025 | 0.58 | 0.74 | 0.92 | 0.99 | 0.98 | 0.73 | 1.00 |
| 1.03 | 0.58 | 0.72 | 0.97 | 1.00 | 0.99 | 0.71 | 1.00 |
| 1.05 | 0.63 | 0.68 | 1.00 | 1.00 | 1.00 | 0.67 | 1.00 |
Table 6. Planar quadrotor: joint success, mean of three policies (500 shared scenarios each); “shuffled”: CAST with its critic’s scores permuted. No certified controller entered a zone or exceeded a budget.
, : CAST 0.59, 0.91, 0.94, 0.97, 0.99; select-then-filter 0.59, 0.79, 0.84, 0.83, 0.86
Zone, joint success: frozen 0.36 (violates 40 %), filter 0.44, critic-free 0.43, MPPI 0.61
task critic: sel.-then-filter 0.69, CAST 0.68, guard 0.70, shuffled 0.43; request-conditioned: CAST 1.00, sel.-then-filter 1.00
Table 10: CAST-V without simulated continuations (unseen zones, 3 policies 500 shared scenarios). Model: simulated continuations. Logs: an ensemble trained on 3000 logged episodes per policy of the critic-free certified controller, labels in hindsight (held-out AUC ). Gain : execution scales the commands, predictions keep the nominal model. Logs minus model under mismatch: [, ] (pooled over both gains); violations at (worst policy; CAST, CAST-V, CAST-VL): 38 %, 6.4 %, 1.6 %. Proposition 8 does not cover the learned estimate.
| Unseen zones | CAST | CAST-V, model | CAST-VL |
| Unicycle, exact model | 0.81 | 0.99 | 0.95 |
| Unicycle, actuator gain 0.85 | 0.70 | 0.96 | 0.93 |
| Unicycle, actuator gain 0.7 | 0.65 | 0.89 | 0.90 |
| Quadrotor, exact model | 0.68 | 0.93 | 0.98 |
Table 10.
| Budget | filter | critic-free | sel.-then-filter | CAST | CAST + guard | CAST-V |
| 0.50† | 0.00 | 0.00 | 0.04 | 0.01 | 0.00 | 0.16 |
| 0.52† | 0.00 | 0.00 | 0.16 | 0.09 | 0.01 | 0.51 |
| 0.55 | 0.02 | 0.03 | 0.60 | 0.57 | 0.35 | 0.86 |
| 0.58 | 0.18 | 0.25 | 0.82 | 0.82 | 0.79 | 0.87 |
| 0.60 | 0.35 | 0.43 | 0.86 | 0.85 | 0.87 | 0.86 |
| 0.65 | 0.48 | 0.51 | 0.88 | 0.88 | 0.88 | 0.89 |
| No request: frozen policy 0.49, critic best-of-8 0.88 |
Table 7. Humanoid: joint success, mean of three policies (300 shared scenarios each). No certified controller exceeded the budget. †: budgets added after the planned run.
| Controller | unseen zones from the family | fixed zone | ||||
| joint | violation | stall | joint | violation | stall | |
| Frozen policy | 0.479 | 0.503 | 0.000 | – | – | – |
| Output CBF filter | 0.721 | 0.000 | 0.205 | 0.726 | 0.000 | 0.207 |
| Predictive safety filter | 0.746 | 0.000 | 0.157 | 0.732 | 0.000 | 0.182 |
| DPCC | 0.741 | 0.000 | 0.205 | 0.735 | 0.000 | 0.219 |
| Critic-free selection | 0.738 | 0.000 | 0.187 | – | – | – |
| Select-then-filter, task critic | 0.860 | 0.000 | 0.113 | 0.867 | 0.000 | 0.115 |
| MPPI (knows model, map, goal) | 0.908 | 0.000 | 0.022 | 0.948 | 0.000 | 0.016 |
| MPC, hard constraints (same) | 0.900 | 0.000 | 0.072 | 0.922 | 0.000 | 0.058 |
| CAST, task critic | 0.809 | 0.000 | 0.147 | 0.788 | 0.000 | 0.159 |
| CAST, matched task-target critic | 0.827 | 0.000 | 0.146 | 0.821 | 0.000 | 0.145 |
| CAST, request-conditioned critic | 0.984 | 0.000 | 0.001 | 0.987 | 0.000 | 0.006 |
| CAST + guard, task critic | 0.786 | 0.000 | 0.161 | – | – | – |
| CAST + guard, matched task-target critic | 0.828 | 0.000 | 0.143 | – | – | – |
| CAST + guard, request-conditioned critic | 0.984 | 0.000 | 0.001 | – | – | – |
| Select-then-filter, matched task-target critic | 0.877 | 0.000 | 0.087 | – | – | – |
| Select-then-filter, request-conditioned critic | 0.984 | 0.000 | 0.001 | 0.987 | 0.000 | 0.003 |
| CAST-V, task critic, | 0.993 | 0.000 | 0.004 | – | – | – |
| CAST-V, task critic, | 0.803 | 0.000 | 0.173 | – | – | – |
| CAST-V, task critic, | 0.829 | 0.000 | 0.151 | – | – | – |
| CAST-V, task critic, | 0.823 | 0.000 | 0.153 | – | – | – |
| Viability only, | 0.991 | 0.000 | 0.008 | – | – | – |
Table 8. Unicycle with a keep-out zone: joint success, violation and stall rates, mean of three policies (500 scenarios each). Left: new zones of the family, unseen by the critics; right: one fixed zone. Matched critics differ only in the label. The planners do not use the policy (one set of 500 scenarios). Arms that draw extra samples use independent latents.
Calibrated forecast margins on Can. Table 11 checks Theorem 1(b) on Can with a slow obstacle seen through a tracker with 5 mm noise. Miscoverage is the share of episodes in which a forecast left its margin; is the share in which a hand-prediction error exceeded the certificate’s slack. With margins calibrated over whole episodes, the closed-loop miscoverage stays at or below its target up to sampling error (largest excess: 0.055 against 0.05) for the filter and for CAST alike, as the theorem states, and collisions stay at or below 0.5 %. Per-step margins give no episode-level guarantee: a forecast leaves them in more than half of the episodes.
References
- [1]Ayush Agrawal and Koushil Sreenath. Discrete control barrier functions for safety-critical control of discrete systems with application to bipedal robot navigation. In Robotics: Science and Systems (RSS), 2017.DOI
- [2]Mohammed Alshiekh, Roderick Bloem, Rüdiger Ehlers, Bettina Könighofer, Scott Niekum, and Ufuk Topcu. Safe reinforcement learning via shielding. In Proceedings of the AAAI Conference on Artificial Intelligence, volume 32, 2018.arxiv.org/abs/1708.08611
- [3]Aaron D. Ames, Xiangru Xu, Jessy W. Grizzle, and Paulo Tabuada. Control barrier function based quadratic programs for safety critical systems. IEEE Transactions on Automatic Control, 62(8):3861–3876, 2017.DOI
- [4]Jean-Pierre Aubin. Viability Theory. Birkhäuser, 1991.
- [5]Ahmad Beirami, Alekh Agarwal, Jonathan Berant, Alexander D’Amour, Jacob Eisenstein, Chirag Nagpal, and Ananda Theertha Suresh. Theoretical guarantees on the best-of-n alignment policy. In Proceedings of the 42nd International Conference on Machine Learning, volume 267 of Proceedings of Machine Learning Research, pages 3580–3602, 2025.arxiv.org/abs/2401.01879
- [7]Craig Boutilier, Alon Cohen, Avinatan Hassidim, Vishay Mansour, Ofer Meshi, Martin Mladenov, and Dale Schuurmans. Planning and learning with stochastic action sets. In Proceedings of the Twenty-Seventh International Joint Conference on Artificial Intelligence (IJCAI), pages 4674–4682, 2018.arxiv.org/abs/1805.02363
- [8]Qingyi Chen, Joseph Ruan, and Zachary Kingston. Safe real-time policy steering via noise-space trajectory optimization for one-step generative policies. arXiv preprint arXiv:2609.21220, 2026.arxiv.org/abs/2609.21220
- [9]Cheng Chi, Siyuan Feng, Yilun Du, Zhenjia Xu, Eric Cousineau, Benjamin Burchfiel, and Shuran Song. Diffusion policy: Visuomotor policy learning via action diffusion. In Robotics: Science and Systems (RSS), 2023.
- [10]Matthew Cleaveland, Insup Lee, George J. Pappas, and Lars Lindemann. Conformal prediction regions for time series using linear complementarity programming. Proceedings of the AAAI Conference on Artificial Intelligence, 38(19):20984–20992, 2024.
- [11]Imre Csiszár. I-divergence geometry of probability distributions and minimization problems. The Annals of Probability, 3(1):146–158, 1975.DOI
- [12]Scott Fujimoto, David Meger, and Doina Precup. Off-policy deep reinforcement learning without exploration. In Proceedings of the 36th International Conference on Machine Learning, volume 97 of Proceedings of Machine Learning Research, pages 2052–2062. PMLR, 2019.arxiv.org/abs/1812.02900
- [13]Darshan Gadginmath, Ahmed Allibhoy, and Fabio Pasqualetti. Provably safe generative sampling with constricting barrier functions. Transactions on Machine Learning Research, 2026.arxiv.org/abs/2602.21429
- [14]Seyed Kamyar Seyed Ghasemipour, Dale Schuurmans, and Shixiang Shane Gu. EMaQ: Expected-max Q-learning operator for simple yet effective offline and online RL. In Proceedings of the 38th International Conference on Machine Learning, volume 139 of Proceedings of Machine Learning Research, pages 3682–3691, 2021.arxiv.org/abs/2007.11091
- [15]E. J. Gumbel. The maxima of the mean largest value and of the range. The Annals of Mathematical Statistics, 25(1):76–84, 1954.DOI
- [16]H. O. Hartley and H. A. David. Universal bounds for mean range and extreme observation. The Annals of Mathematical Statistics, 25(1):85–99, 1954.DOI
- [17]Kai-Chieh Hsu, Haimin Hu, and Jaime F. Fisac. The safety filter: A unified view of safety-critical control in autonomous systems. Annual Review of Control, Robotics, and Autonomous Systems, 7:47–72, 2024.arxiv.org/abs/2309.05837
- [18]Songqiao Hu, Zeyi Liu, Shuang Liu, Jun Cen, Zihan Meng, Shihefeng Wang, Xiang Li, and Xiao He. VLSA: Vision-language-action models with plug-and-play safety constraint layer. In IEEE/RSJ International Conference on Intelligent Robots and Systems (IROS), 2026. arXiv:2512.11891.arxiv.org/abs/2512.11891
- [19]Sham Kakade and John Langford. Approximately optimal approximate reinforcement learning. In International Conference on Machine Learning (ICML), pages 267–274, 2002.
- [20]Jacky Kwok, Christopher Agia, Rohan Sinha, Matt Foutter, Shulu Li, Ion Stoica, Azalia Mirhoseini, and Marco Pavone. RoboMonkey: Scaling test-time sampling and verification for vision-language-action models. In Proceedings of The 9th Conference on Robot Learning, volume 305 of Proceedings of Machine Learning Research, pages 3200–3217, 2025.arxiv.org/abs/2506.17811
- [21]Lars Lindemann, Matthew Cleaveland, Gihyun Shim, and George J. Pappas. Safe planning in dynamic environments using conformal prediction. IEEE Robotics and Automation Letters, 8(8):5116–5123, 2023.arxiv.org/abs/2210.10254
- [22]Ajay Mandlekar, Danfei Xu, Josiah Wong, Soroush Nasiriany, Chen Wang, Rohan Kulkarni, Li Fei-Fei, Silvio Savarese, Yuke Zhu, and Roberto Martín-Martín. What matters in learning from offline human demonstrations for robot manipulation. In Conference on Robot Learning (CoRL), 2021.arxiv.org/abs/2108.03298
- [23]Angelo Moroncelli, Matteo Rufolo, Gunes Cagin Aydin, Asad Ali Shahid, and Loris Roveda. Diffusion sequence models for generative in-context meta-learning of robot dynamics. arXiv preprint arXiv:2604.13366, 2026.arxiv.org/abs/2604.13366
- [24]Mitsuhiko Nakamoto, Oier Mees, Aviral Kumar, and Sergey Levine. Steering your generalists: Improving robotic foundation models via value guidance. In Conference on Robot Learning (CoRL), 2024.arxiv.org/abs/2410.13816
- [25]Kensuke Nakamura, Arun L. Bishop, Steven Man, Aaron M. Johnson, Zachary Manchester, and Andrea Bajcsy. How to train your latent control barrier function: Smooth safety filtering under hard-to-model constraints. In Proceedings of the 8th Annual Learning for Dynamics and Control Conference, volume 331 of Proceedings of Machine Learning Research, pages 145–168, 2026.
- [26]Junyong Park, Hyeontae Sung, and Heejin Ahn. Sampling-based safety filter with probabilistic restrictiveness guarantee. arXiv preprint arXiv:2604.22149, 2026.arxiv.org/abs/2604.22149
- [27]Allen Z. Ren, Justin Lidard, Lars L. Ankile, Anthony Simeonov, Pulkit Agrawal, Anirudha Majumdar, Benjamin Burchfiel, Hongkai Dai, and Max Simchowitz. Diffusion policy policy optimization. In International Conference on Learning Representations (ICLR), 2025.arxiv.org/abs/2409.00588
- [28]Ralf Römer, Alexander von Rohr, and Angela P. Schoellig. Diffusion predictive control with constraints. In Proceedings of the 7th Annual Learning for Dynamics and Control Conference, volume 283 of Proceedings of Machine Learning Research, pages 791–803, 2025.arxiv.org/abs/2412.09342
- [29]Ralf Römer, Julian Balletshofer, Jakob Thumm, Marco Pavone, Angela P. Schoellig, and Matthias Althoff. From demonstrations to safe deployment: Path-consistent safety filtering for diffusion policies. In IEEE International Conference on Robotics and Automation (ICRA), 2026. arXiv:2511.06385.arxiv.org/abs/2511.06385
- [30]Andrea Rosasco, Federico Ceola, Giulia Pasquale, and Lorenzo Natale. KDPE: A kernel density estimation strategy for diffusion policy trajectory selection. In Proceedings of the 9th Conference on Robot Learning, volume 305 of Proceedings of Machine Learning Research, pages 1210–1224, 2025.arxiv.org/abs/2508.10511
- [31]Krishnan Srinivasan, Benjamin Eysenbach, Sehoon Ha, Jie Tan, and Chelsea Finn. Learning to be safe: Deep RL with a safety critic. arXiv preprint arXiv:2010.14603, 2020.arxiv.org/abs/2010.14603
- [32]Brijen ThananJeyan, Ashwin Balakrishna, Suraj Nair, Michael Luo, Krishnan Srinivasan, Minho Hwang, Joseph E. Gonzalez, Julian Ibarz, Chelsea Finn, and Ken Goldberg. Recovery RL: Safe reinforcement learning with learned recovery zones. IEEE Robotics and Automation Letters, 6 (3):4915–4922, 2021.arxiv.org/abs/2010.15920
- [33]Vladimir Vovk, Alexander Gammerman, and Glenn Shafer. Algorithmic Learning in a Random World. Springer, 2005.
- [34]Kim P. Wabersich and Melanie N. Zeilinger. A predictive safety filter for learning-based control of constrained nonlinear dynamical systems. Automatica, 129:109597, 2021.arxiv.org/abs/1812.05506
- [35]Ziqian Wang and Zhen Zhang. Monotone viability learning for offline safe reinforcement learning. arXiv preprint arXiv:2611.07616, 2026.arxiv.org/abs/2611.07616
- [36]Grady Williams, Nolan Wagener, Brian Goldfain, Paul Drews, James M. Rehg, Byron Boots, and Evangelos A. Theodorou. Information theoretic MPC for model-based reinforcement learning. In IEEE International Conference on Robotics and Automation (ICRA), pages 1714–1721, 2017.DOI
- [37]Wei Xiao, Tsun-Hsuan Wang, Chuang Gan, Ramin Hasani, Mathias Lechner, and Daniela Rus. SafeDiffuser: Safe planning with diffusion probabilistic models. In International Conference on Learning Representations (ICLR), 2025.








