Chapter 6: Generate Multiple Plausible Actions — Diffusion Policy and Flow Matching

Overview

Chapter 5 compared plain behavior cloning (BC), deterministic action chunks, and ACT under one dataset and controller contract. If those baselines are sufficient, this chapter supplies no reason to add another model. A generative policy becomes a candidate only when one observation genuinely admits several valid action trajectories and single regression or a limited latent model loses that structure.

Suppose an obstacle can be passed on the left or right and both paths succeed. Pointwise regression can produce a mean path aimed between the two modes. But if the demonstrations diverge because camera timestamps are wrong, task phases are mixed, operator styles differ, or calibration drifted, a generator may reproduce the mixture more elegantly instead of fixing it. The first question is not “diffusion or flow?” It is whether multimodality belongs to the task or to a broken data contract.

Evidence boundary: The conditional action-sequence distribution, iterative denoising, receding-horizon mechanism, and source-specific benchmark aggregate for Diffusion Policy are inspected in the original source ^[5]. The velocity-field objective of Flow Matching is presented from the original generative-model formulation ^[4], but the current claim ledger still lacks an exact robot-policy body locator. Speed results for FlowPolicy and ManiCM remain abstract-level candidates in this packet; they are not promoted to end-to-end hardware-latency or safety conclusions. The timing budget, stale rejection, feasibility projection, OOD/recovery gates, and promotion rules below are S12 engineering synthesis, not universal safe settings.

After reading this chapter... - You can distinguish multiple valid actions from label noise and missing task state. - You can explain conditional action diffusion, denoising, and receding-horizon execution. - You can distinguish flow-matching velocity regression and ODE sampling from a diffusion sampler. - You can compare BC, ACT/cVAE, energy models, diffusion, and flow under the same action semantics and timing budget. - You can calculate perception-to-controller latency and action age rather than citing only neural function evaluations. - You can promote a generated chunk only below feasibility, OOD, contact, watchdog, and recovery gates.

The experiment question is: With the Chapter 4 dataset and Chapter 5 matched baselines frozen, do diffusion or flow generators preserve useful trajectory modes during approach and insertion, and is the gain large enough to justify sampling latency, stale actions, constraint rejections, and recovery cost?

1. First prove why the mean action fails

Under squared loss, deterministic regression approaches the conditional mean when model and data are sufficient:

$$

\pi^*(o)=\arg\min_{\hat a}\mathbb{E}[\|a-\hat a\|_2^2\mid o]

=\mathbb{E}[a\mid o].

$$

If left-bypass action a^{(L)} and right-bypass action a^{(R)} are equally likely under one observation, their mean can occupy a low-density and physically poor region directed at the obstacle. Averaging whole action sequences can also blur gripper-closing time or insertion direction.

That equation alone does not establish the need for a generator. If goal side, object identity, task phase, or operator intent is absent from the observation, the problem is missing conditioning. If the modes come from different calibration epochs or clock alignments, it is dataset corruption. If one mode repeatedly fails but its success label is wrong, it is target contamination. A density model can conceal all three.

1.1 Multimodality audit

Analyze actions inside task phase and causal split before training a generator.

Implicit Behavioral Cloning uses an energy landscape and candidate optimization as another approach to multimodal action ^[3]. ACT combines a conditional VAE with action chunks ^[6]. BAKU helps separate representation, transformer trunk, action head, and temporal design so that a head alone is not credited for every difference ^[7]. None repairs misaligned labels.

1.2 Separate trajectory modes from pointwise noise

A left-versus-right route is a trajectory-level mode that stays coherent over several steps. Teleoperator tremor, encoder noise, and camera quantization can be pointwise variation. The case for a generator is stronger when cluster identity persists over a sequence.

Establish three baselines first:

1. plain deterministic BC;
2. deterministic chunked BC with the same encoder and horizon;
3. the Chapter 5 ACT/cVAE baseline.

If chunked BC removes the mean action, temporal context rather than density modeling may have been missing. If adding task phase collapses the modes, partial observability was responsible. If ACT samples are diverse but unrelated to task condition, the latent may encode style or noise rather than useful strategy. Diffusion and flow enter only after this audit.

2. Diffusion Policy conditionally denoises an action sequence

Diffusion models combine a forward process that adds noise to data with a learned reverse process that removes noise under conditioning ^{[1] [2]}. In a robot policy, the generated object is a future action sequence A_t=[a_t,\ldots,a_{t+K-1}], not an image.

A simplified discrete forward process is:

$$

q(A^k\mid A^{k-1})=

\mathcal{N}(\sqrt{1-\beta_k}A^{k-1},\beta_k I),

$$

$$

A^k=\sqrt{\bar\alpha_k}A^0+

\sqrt{1-\bar\alpha_k}\epsilon,

\qquad \epsilon\sim\mathcal{N}(0,I).

$$

A^0 is a demonstration chunk and k a noise level. The network receives noisy A^k, step k, and observation context c_t, then predicts noise or an equivalent score parameterization. A teaching form of the noise-prediction loss is:

$$

\mathcal{L}_{diff}=

\mathbb{E}_{A^0,k,\epsilon}

\left[\left\|\epsilon-epsilon_\theta(A^k,k,c_t)\right\|_2^2\right].

$$

At deployment, sampling begins from a noise chunk A^N and applies reverse updates to obtain an A^0 candidate. A diffusion step is an internal neural-sampling operation. An action timestep is a physical reference consumed by a controller. Calling both a “step” obscures the difference between compute budget and motion horizon.

2.1 Conditional distribution and receding horizon

Diffusion Policy represents a conditional distribution over action sequences and executes the leading portion under receding-horizon control before conditioning again on a new observation ^[5].

For prediction length K and execution horizon H_e\le K at time t:

$$

\hat A_t\sim p_\theta(A_t\mid O_{t-H_o+1:t}),

\qquad

\text{execute }\hat A_t[0:H_e],

\qquad

\text{reobserve and resample}.

$$

A longer K can support trajectory coherence, while a longer H_e delays reaction to contact or object slip. Running the full sampler for every action can instead miss compute deadlines. Prediction horizon, execution horizon, sampler steps, and invocation rate must remain separate configuration fields.

The original Diffusion Policy study reports 12 tasks across four manipulation-benchmark families and a 46.9% average improvement over its own matched baselines ^[5]. That aggregate belongs to its task, observation, action, training, and evaluation conditions. It is not comparable with unmatched ACT or later flow-policy results.

The number is not a local acceptance threshold. The tabletop experiment must rematch dataset split, encoder budget, action representation, horizon, reset protocol, evaluator, seed count, and controller interface across BC, ACT, and diffusion.

2.2 What changes when denoising steps are reduced?

Reducing sampler steps N lowers neural evaluations, but can also change sample quality, mode coverage, and temporal smoothness. Raising N can increase queue wait and observation age as well as model compute. Scheduler and stochasticity matter. Record at least:

• training noise schedule and number of noise levels;
• inference sampler and number of function evaluations (NFE);
• stochastic-seed policy and deterministic evaluation mode;
• observation H_o, prediction K, and execution H_e horizons;
• action normalization, rotation representation, and gripper encoding;
• sample count, selection rule, and feasibility projection;
• preprocessing device, precision, batch size, and warm-up;
• invocation rate, controller deadline, and queue replacement rule.

Selecting the “best” of several samples introduces another policy component. A selector using future truth or the test evaluator leaks information. A selector limited to kinematic and collision feasibility still needs an owner and recorded rejection reason.

3. Flow matching learns a velocity field and transports with an ODE

Flow matching chooses a probability path p_\tau, \tau\in[0,1], between noise p_0 and data p_1, then trains a time-dependent velocity field v_\theta(x,\tau,c) that transports samples along the path ^[4]. Given a target conditional velocity u_\tau(x\mid x_1), a teaching objective is:

$$

\mathcal{L}_{FM}=

\mathbb{E}_{\tau,x_1,x_\tau}

\left[\left\|v_\theta(x_\tau,\tau,c)-u_\tau(x_\tau\mid x_1)\right\|_2^2\right].

$$

Inference transports initial noise x(0)\sim p_0 to an action sample x(1) by integrating:

$$

\frac{dx(\tau)}{d\tau}=v_\theta(x(\tau),\tau,c),

\qquad x(0)\sim p_0.

$$

ODE steps, adaptive tolerance, and path geometry influence compute and approximation. “Flow produces an action in one pass” may describe a particular consistency or distillation variant, not generic flow matching.

The original formulation supports the generic statement that flow matching regresses velocity fields of probability paths ^[4]. The current Chapter 6 ledger still lacks an exact body locator connecting that objective to robot-policy latency, feasibility, or success. PointFlowMatch and FlowPolicy apply conditional flow ideas to robot actions ^{[10] [14]}, but their results are not promoted to hardware generalization here. The operative caveat is that a generic velocity-field objective does not establish robot-policy latency, feasibility, or task success.

3.1 How to read robot flow-policy variants

PointFlowMatch studies conditional flow with point-cloud observations and pose representations ^[10]. Affordance-based flow connects visual affordances with trajectory generation, but its open-loop setting, camera/background sensitivity, and dynamics limits must remain visible ^[9]. FlowPolicy targets single-step generation through consistency flow matching ^[14]. ManiCM targets the repeated-denoising bottleneck by distilling a 3D diffusion action model into a consistency prediction ^[8].

Do not collapse these into “flow is faster and more accurate than diffusion.” Some use RGB and others point clouds; 3D preprocessing may or may not be counted; evidence may be simulation or hardware, open-loop or receding horizon; action representations and controller rates differ. Exact FlowPolicy and ManiCM result locators remain unresolved in the packet, so abstract acceleration factors are not local expectations.

3.2 Compare VAE, ACT, diffusion, and flow on shared axes

This taxonomy is not a ranking. A VAE forward pass is not guaranteed to win end-to-end latency, and many diffusion NFE do not automatically miss a deadline. Camera transfer, encoders, preprocessing, queues, and the controller boundary may dominate.

4. Separate neural sampling time from end-to-end latency

A paper’s inference time often measures network forward passes or sampling only. Action age at a robot includes every stage from camera exposure to controller acceptance:

$$

L_{e2e}=L_{exposure}+L_{capture}+L_{decode}+L_{transfer}

+L_{pre}+L_{sample}+L_{select}+L_{project}+L_{network}+L_{queue},

$$

$$

age(a_j)=t^{controller\_accept}_j-t^{observation\_event}.

$$

One-step or few-step neural sampling time is not equivalent to perception-to-controller latency. Current LeRobot asynchronous-inference documentation separates RobotClient execution from PolicyServer chunk prediction and describes queue-based overlap ^[17]. That official system boundary is inspected, but it supplies neither hard real-time behavior nor stale-state safety. Exact result locators for FlowPolicy and ManiCM remain unresolved.

4.1 Worked timing budget

The following illustrative trace demonstrates accounting. Its values are not hardware recommendations.

In this trace, generator A’s p95 path sums to $31+12+15+55+7+19=139$ ms; B’s path sums to $107$ ms. This does not establish that B is the better policy. If B produces more infeasible samples or misses modes and requires another candidate, total decision time grows. If A prefetches a valid chunk early enough, the longer sampler may still meet the deadline.

NFE is useful, but it is not a controller deadline. Report it with:

• cold and warm p50, p95, maximum latency;
• observation age at sampling start and controller acceptance;
• candidate rejection and resampling counts;
• queue occupancy, drop, reorder, replacement, and stale counts;
• prediction K, execution H_e, and remaining valid horizon;
• missed invocations, safe holds, classical fallbacks, and interventions;
• GPU contention and memory-allocation spikes;
• success and recovery under the same deadline.

4.2 Chunk-queue validity

Define in advance whether a late chunk causes continued execution of an old chunk, a hold, or a classical fallback. Do not execute a stale free-space prediction after transition to contact. Attach:

chunk_id
condition_observation_event_time
policy_checkpoint_hash
sampler_config_hash
action_start_time / action_period
valid_until
task_phase
calibration_epoch
predecessor_chunk_id

The executor discards a chunk after valid_until, observation divergence, a phase transition, a force/collision event, or calibration mismatch. Blended chunks pass feasibility projection again. Smoothness is not authority.

5. Do not rank diffusion and flow without a matched comparison

A local diffusion-versus-flow comparison is valid only when task, embodiment, dataset, action space, horizon, preprocessing, resets, and controller deadline are matched. The current corpus contains no matched hardware study that closes latency, feasibility, OOD, and recovery together. This is therefore an S12 experimental-design requirement, not a result already proven by the papers.

5.1 Minimum comparison matrix

Giving one method a point cloud and another RGB compares representations as well as generators. Comparing simulation with real hardware does not isolate deployment. Comparing one-step and 16-step sampling without distillation cost or candidate rejection is not a system-cost comparison.

5.2 Local experiment ladder

1. Offline density audit: analyze held-out chunk reconstruction, diversity, and likelihood surrogates by phase without merging incomparable metrics.
2. Shadow feasibility: generate multiple candidates for identical observations and count representation, IK, workspace, collision, velocity, and contact-precondition rejections.
3. Simulation regression: use identical initial-state bins and perturbations; measure success, recovery, timeout, and action age.
4. Asynchronous stress: inject camera delay, GPU contention, network jitter, and queue reorder; verify stale rejection and fallback.
5. Bounded-hardware candidate: only an independently reviewed method gets a reduced-envelope trial card. This chapter does not authorize execution.

PointFlowMatch simulation evidence, Affordance Flow’s real/open-loop setting, and FlowPolicy’s simulation speed claim are source-specific ^{[10] [9] [14]}. They do not become rows in one leaderboard.

6. Generated trajectories still sit below controllers and safety

A generated action sequence is a proposal. It can contain low-density samples, OOD observations, numerical integration errors, stale conditioning, invalid rotations, collision, excessive velocity, or excessive contact. Probability and feasibility are different properties.

observation + task phase
  ↓
diffusion / flow generator
  ↓ candidates + condition time + validity
candidate diagnostics / optional selector
  ↓
IK or joint/workspace projection · collision/rate limits
  ↓
receding-horizon executor · stale/reorder/drop rules
  ↓
Chapter 3 contact controller
  ↓
vendor real-time controller

independent safety supervisor:
  force/collision gate · watchdog · protective stop · E-stop

Requiring feasibility projection, OOD/recovery handling, and independent contact and safety layers is an S12 safety-architecture rule. The current ledger lacks exact primary-body locators proving this whole chain universally, so this chapter does not claim that Diffusion Policy, Reactive Diffusion, or FlowPolicy validated it in full ^{[5] [16] [14]}.

6.1 Feasibility is not one Boolean

Layer candidate verdicts:

• representation-valid: finite values, shapes, quaternion/rotation validity, gripper enum;
• kinematically valid: joint limits, IK reachability, singularity margin, workspace;
• geometrically valid: collision and swept volume;
• dynamically/interface valid: velocity, acceleration, jerk, controller mode, timestamp;
• contact-phase valid: allowed direction, force envelope, surface/task phase;
• fresh: condition observation, calibration, task phase, and queue validity still match.

If projection is large, do not force a sample into feasibility and count only the final success. Retain the proposal, projected action, reason, and magnitude. If projection consistently removes one mode, policy support and the feasible set are misaligned.

6.2 OOD and recovery

Do not interpret sample variance or denoising residual automatically as an OOD score. Evaluate calibration change, unseen objects, lighting shifts, and contact anomalies separately. Candidate diagnostics include conservative support checks, encoder distance, ensemble disagreement, and reconstruction residual. Record validation coverage and false-negative cost for every threshold.

Recovery is more than resampling. Define by phase whether the system holds safely, invokes a retreat primitive, returns through a classical planner, asks for human intervention, or aborts. Reactive Diffusion offers a visual–tactile slow/fast policy direction ^[16], but its apparatus does not replace local contact-safety evidence. TRANSIC provides a correction-related research branch ^[11], while human authority and correction semantics remain under the Chapter 4–5 contract.

7. Failure symptoms and diagnosis order

Diagnose in the order data semantics → multimodality → conditioning → generator training → sampler/solver → timing/queue → feasibility → contact controller → evaluator. Starting with sampler tuning can conceal missing task variables or stale camera frames.

8. Promotion gates and metric checklist

Gate A — need for a generator

Freeze matched BC, deterministic chunk, and ACT/cVAE baselines. Inspect action clusters and outcomes near similar observations. Pass when multiple valid modes or a recovery benefit remain after fixing time, calibration, and phase.

Gate B — offline reproducibility

Pin the generator configuration, checkpoint, dataset UUIDs, normalization, seed, and sampler/solver. Pass when save/reload reproduces evaluation fixtures, sample metadata, NFE, and latency benchmarks.

Gate C — feasibility and temporal consistency

Shadow-test several candidates on held-out observations and corrupted fixtures. Pass when representation failures, projection, rejection, boundary jerk, and stale chunks are reported, and out-of-threshold candidates never reach the executor stub.

Gate D — matched simulation and stress

Compare BC, ACT, diffusion, and flow with identical initial states, resets, deadlines, and perturbations. Inject camera delay, compute contention, and network jitter. Pass when action age, deadline misses, fallback, intervention, and recovery cost meet acceptance limits alongside success.

Gate E — hardware trial card only

An independent reviewer writes a trial card with reduced workspace, speed, force envelope, spotter, stop path, abort thresholds, and rollback. The chapter prompt neither moves a robot nor modifies safety settings.

Package these artifacts for every candidate:

• dataset/split UUIDs, action semantics, calibration epoch;
• matched BC, chunked-BC, and ACT baseline report;
• architecture, checkpoint, training seed, config hash;
• sampler/solver, schedule/path, NFE, precision, warm-up;
• H_o, K, H_e, invocation rate, controller deadline;
• latency-component p50/p95/max and action-age distribution;
• diversity, mode coverage, feasibility rejection, projection delta;
• temporal jerk, replacement, stale/drop/reorder counts;
• per-task success, recovery, intervention, reset, and intervals;
• OOD probes, fallback transitions, watchdog, safety-event report;
• matched comparison matrix and unmatched-evidence caveats.

9. A bounded Codex prompt

Goal
Implement an offline and simulation-only matched comparison of deterministic
chunked BC, ACT/cVAE, one conditional action-diffusion policy, and one
conditional flow-matching policy for the versioned tabletop-insertion dataset.

Context
- Use the frozen Chapter 4 episode/split manifests and Chapter 5 action contract.
- Predict the same mapped action representation and preserve H_o, K, H_e,
  controller rate, and deadlines in one comparison config.
- Existing constraint projection, contact controller, watchdog, and stop logic
  are test fixtures; do not modify or bypass them.

Constraints
- Pin original repositories/dependencies and record exact commits.
- Use the same encoder and parameter budget where possible; report exceptions.
- Separate diffusion steps, flow-solver NFE, policy invocation, and action steps.
- Measure camera-to-controller latency components, action age, queue state,
  candidate rejection, projection delta, and resampling.
- Do not claim a ranking from unmatched papers or abstract-only speed numbers.
- Keep raw generated candidates, projected actions, and rejection reasons.

Done when
- Multimodality audit distinguishes hidden state, corrupted labels, and valid modes.
- Save/reload fixtures reproduce deterministic evaluation samples and metadata.
- The evaluator compares all methods on identical episode UUIDs, reset bins,
  perturbations, action semantics, horizons, deadlines, and seeds.
- Tests inject stale observations, camera delay, GPU contention, reordered chunks,
  infeasible rotations, collisions, and contact-phase changes.
- Reports include latency p50/p95/max, NFE, action age, mode coverage, feasibility,
  success, recovery, intervention, fallback, and confidence intervals.
- A method cannot pass while stale or rejected actions reach the controller stub.

Safety
- Use recorded observations, controller stubs, kinematic checks, and simulation only.
- Never connect to hardware, call send_action, clear a fault, alter force/speed
  limits, or grant a learned policy safety authority.
- Produce a separate human-reviewed hardware trial card; do not execute it.

The prompt turns the comparison contract into executable tests rather than merely running model code. Tutorial snippets and repository examples are API-reading aids, not hardware authorization ^[15].

10. Evidence tiers and open questions

• Inspected original scope: conditional denoising over action sequences, receding horizon, and the source-specific Diffusion Policy aggregate ^[5]; generative formulations for DDPM, score models, and flow matching ^{[1] [2] [4]}.
• Robot-policy candidates: PointFlowMatch, Affordance Flow, FlowPolicy, ManiCM, and Reactive Diffusion represent different observation, sampler, and contact choices ^{[10] [9] [14] [8] [16]}. Claims lacking exact locators and matched deployment remain identity and experiment-design seeds.
• Current official system boundary: LeRobot async documentation describes client/server chunk queues, not hard real-time, stale-state safety, or an independent supervisor ^[17].
• Tutorial map: the Capuano tutorial’s VAE→diffusion→flow sequence is pedagogical ^[15]. Method results and current APIs return to original and official sources.

Open questions remain. How can mode coverage be measured credibly without a tractable likelihood? How should flow ODE tolerance and diffusion stochasticity be calibrated under a controller deadline? When projection truncates a distribution, should feasible sets enter training or remain post-hoc gates? How should slow visual generation and fast tactile correction be separated during contact? Can OOD and recovery be evaluated jointly while safety authority remains independent?

EgoMimic and Octo raise broader data and generalist-policy questions ^{[12] [13]}, but detailed cross-embodiment pretraining and generalist-model comparison belong to #S13. S12 does not add them to an unmatched local diffusion/flow leaderboard.

Manufacturing Cell Checkpoint

The model owner approves sample quality, the perception owner observation age, the controller owner command validity and deadline, and the safety owner watchdog, stop, and fallback. One statement such as “inference is 10 ms” cannot combine those responsibilities.

What to Learn Next

Chapter 7 asks where RL belongs above an imitation policy. A diffusion or flow model can represent several demonstration modes without optimizing reward or automatically discovering unseen recovery. The handoff to Chapter 7 is therefore not “the generator is newer.” It is a fixed policy/controller interface, failure taxonomy, offline and simulation evidence, intervention cost, and a measurable residual that RL might improve.

Plain BC and ACT from Chapter 5 remain baselines. If a generative head’s gain does not exceed its deadline, feasibility, and recovery costs, return to the simpler policy. VLA action tokenization, generalist pretraining, cross-embodiment adaptation, world models, and agentic planning belong to #S13. No future upper-level model bypasses the Chapter 3 contact controller, Chapter 4 provenance, or Chapter 5–6 timing and constraint contracts.

References

1. Ho, J., Jain, A., & Abbeel, P. (2020). Denoising Diffusion Probabilistic Models. NeurIPS. arXiv:2006.11239.
2. Song, Y., Sohl-Dickstein, J., Kingma, D. P., et al. (2021). Score-Based Generative Modeling through Stochastic Differential Equations. ICLR. arXiv:2011.13456.
3. Florence, P., Lynch, C., Zeng, A., & Ramirez, O. A. (2022). Implicit Behavioral Cloning. CoRL. arXiv:2109.00137.
4. Lipman, Y., Chen, R. T. Q., Ben-Hamu, H., Nickel, M., & Le, M. (2022). Flow Matching for Generative Modeling. ICLR 2023. arXiv:2210.02747.
5. Chi, C., et al. (2023). Diffusion Policy: Visuomotor Policy Learning via Action Diffusion. RSS. arXiv:2303.04137. Terry's English explainer.
6. Zhao, T. Z., Kumar, V., Levine, S., & Finn, C. (2023). Learning Fine-Grained Bimanual Manipulation with Low-Cost Hardware. RSS. arXiv:2304.13705.
7. Haldar, S., Peng, Z., & Pinto, L. (2024). BAKU: An Efficient Transformer for Multi-Task Policy Learning. arXiv:2406.07539.
8. Lu, G., et al. (2024). ManiCM: Real-time 3D Diffusion Policy via Consistency Model for Robotic Manipulation. arXiv:2406.01586.
9. Zhang, F., & Gienger, M. (2024). Affordance-based Robot Manipulation with Flow Matching. arXiv:2409.01083.
10. Chisari, E., et al. (2024). Learning Robotic Manipulation Policies from Point Clouds with Conditional Flow Matching. CoRL. arXiv:2409.07343.
11. Jiang, Y., et al. (2024). TRANSIC: Sim-to-Real Policy Transfer by Learning from Online Correction. CoRL.
12. Kareer, S., et al. (2024). EgoMimic: Scaling Imitation Learning via Egocentric Video. arXiv:2410.24221.
13. Octo Model Team (2024). Octo: An Open-Source Generalist Robot Policy. arXiv:2405.12213.
14. Zhang, Q., et al. (2024b). FlowPolicy: Enabling Fast and Robust 3D Flow-based Policy via Consistency Flow Matching for Robot Manipulation. arXiv:2412.04987v2.
15. Capuano, F., Pascal, C., Zouitine, A., Wolf, T., & Aractingi, M. (2025). Robot Learning: A Tutorial. arXiv:2510.12403v1. DOI: 10.48550/arXiv.2510.12403.
16. Xue, H., et al. (2025). Reactive Diffusion Policy: Slow-Fast Visual-Tactile Policy Learning for Contact-Rich Manipulation. RSS. arXiv:2503.02881.
17. Hugging Face (2026). LeRobot Asynchronous Inference. Official documentation, accessed 2026-07-15.
18. Han Xue et al. (2025). Reactive Diffusion Policy: Slow-Fast Visual-Tactile Policy Learning for Contact-Rich Manipulation (TactAR). Annotated primary reading. arXiv:2503.02881. — Role: primary evidence for separating slow visual planning from fast tactile reaction in a contact-rich policy. Limitation: platform, task, data, and evaluation conditions are specific and do not establish general safety or transfer.