Diffusion Policy: Visuomotor Policy Learning via Action Diffusion

A robot policy that generates a short sequence of future actions by denoising random noise.

Behavior cloning trains a network to copy demonstrations. When demonstrators handled the same situation in two different ways, a regression network outputs the average of the two, and on a robot the average is often a collision. Diffusion Policy replaces the regression with a diffusion model over action sequences and reports an average improvement of 46.9% over the best prior method on its simulation benchmarks.

On the Push-T task, at each decision the policy reads its last two observations, starts from 32 random numbers, and runs one denoising network 10 to 100 times to turn them into 16 future end-effector positions. The robot executes the first 8 and then decides again.

Behavior cloning teaches a robot from demonstrations. A person teleoperates the arm, the system records what the cameras and joint sensors reported together with the command the person sent, and a network is trained to map the first to the second. It is supervised learning, and the simplest version is regression with a squared-error loss.

Regression breaks when demonstrations disagree. Picture a T-shaped block on a table, the robot's end-effector below it, and a target on the far side. Some demonstrators went around the left of the block and some around the right. For that one camera image the recorded next moves fall into two groups, and the prediction with the lowest squared error is their mean: straight ahead, into the block. Demonstrations with several valid ways of doing the same thing are called multimodal, and each way is a mode.

Diffusion Policy, by Cheng Chi, Zhenjia Xu and colleagues at Columbia, the Toyota Research Institute, MIT and Stanford, stops predicting a single action. It trains a diffusion model, the kind of generative model that produces images by removing noise step by step, to generate a sequence of future actions given the latest observations. Each decision starts the sampler from different random noise, and the sample ends in one mode, so the robot goes left on some runs and right on others.

Five choices make it work on physical robots, and the sections below take them in order: noise prediction over action sequences, observations used only as conditioning, a loop that predicts 16 actions and executes 8 before re-planning, position targets instead of velocity commands, and a faster sampler. After those come the argument for why it trains more stably than energy-based policies, a check on a linear system with a known optimal controller, and the results.

Why averaging demonstrations fails

Write the policy as a function $f(\mathbf{o})$ from observation to action, trained to minimize the expected squared error against the demonstrated action $\mathbf{a}$. For each observation the minimizer is the conditional mean of the demonstrated actions:

If half the demonstrations at one observation move the end-effector 1 cm left and half move it 1 cm right, the trained network moves it 0 cm sideways, toward the block, and adding more demonstrations of both routes only estimates that mean more precisely.

Earlier work tried three repairs. Mixture heads: the robomimic benchmark's BC-RNN, called LSTM-GMM in the paper, puts a Gaussian mixture on the output of an LSTM, so it can represent several modes, but the number of mixture components is fixed before training. Discretization: BET (Behavior Transformer) clusters the demonstrated actions with k-means and predicts a cluster plus an offset, which again needs the number of clusters in advance; a full grid over the action space needs a number of bins that grows exponentially with the action dimension. Energy-based models: IBC (Implicit Behavioral Cloning) learns a scalar energy $E(\mathbf{o}, \mathbf{a})$ and picks the action with the lowest energy, which allows any number of modes but is hard to train, as a later section explains.

In the paper's Push-T case study (its Fig. 3), LSTM-GMM and IBC both end up biased toward one side, and BET fails to commit to a mode, so consecutive actions come from different routes. Figure 1 draws the three kinds of output at the moment of decision. Toggle between them and watch the strip of sampled next actions below the block.

The Diffusion Policy panel shows two separate properties. Coverage is a property across rollouts: over many runs, both routes appear. Commitment is a property within a rollout: one run follows one route from start to finish. A policy that interpolates between left and right at every step has neither, and a policy that always goes left has commitment without coverage. The readout in the lower-right corner counts coverage, not commitment.

Later robot models solved multimodality the discretizing way at much larger scale: RT-2 and OpenVLA emit each action dimension as a token from a language model, one dimension after another, which avoids the exponential grid. Diffusion Policy keeps actions continuous and samples all the numbers of an action sequence together.

How a diffusion model adds and removes noise

Diffusion Policy uses a denoising diffusion probabilistic model (DDPM) without changes to the algorithm. A DDPM is trained to undo a fixed noising process, so the noising process comes first. Take a clean sample, here an action sequence $\mathbf{A}^0$, and mix it with Gaussian noise in $K$ levels. The noised version at level $k$ has a closed form:

The numbers $\bar{\alpha}_k$ form the noise schedule. They fall from 1 at $k=0$ (clean) to about 0 at $k=K$ (pure noise), and the squares of the two coefficients always sum to 1. Diffusion Policy uses $K = 100$ and the squared cosine schedule from iDDPM. On that schedule, $k = 50$ gives $0.70\,\mathbf{A}^0 + 0.71\,\boldsymbol{\epsilon}$, $k = 90$ gives $0.16\,\mathbf{A}^0 + 0.99\,\boldsymbol{\epsilon}$, and at $k = 100$ the signal coefficient is below 0.001.

Training teaches a network $\boldsymbol{\epsilon}_\theta$ to recover the noise. Draw a clean example, draw a level $k$ uniformly, draw $\boldsymbol{\epsilon}$, build $\mathbf{A}^k$ with (A), and regress the network's output onto $\boldsymbol{\epsilon}$. The paper writes a generic sample as $\mathbf{x}$ rather than $\mathbf{A}$, so $\mathbf{x}^0$ is the clean sequence $\mathbf{A}^0$ and $\mathbf{x}^k$ its noised copy $\mathbf{A}^k$. It writes the loss in a shorthand where $\boldsymbol{\epsilon}^k$ is noise "with appropriate variance for iteration $k$" and the scaling of (A) is left implicit:

The official code builds the input with (A) and uses unit-variance $\boldsymbol{\epsilon}$ as the target. Equation numbers written as digits on this page are the paper's; letters mark equations the page adds. Figure 2 shows one training input: a demonstrated route and the noised copy the network receives at the chosen level.

At $k = 30$ the route is still readable under noise with coefficient 0.46; by $k = 90$, with signal coefficient 0.16, it is hard to see. With the linear button, $k = 100$ still has signal coefficient 0.60, because squeezing DDPM's 1000-level constants ($\beta$ from $10^{-4}$ to 0.02) into 100 levels leaves $\bar\alpha_{100} = 0.36$. A sampler that starts from pure noise would then start from inputs the network never saw in training. The cosine schedule is defined directly through $\bar\alpha_k$, so it reaches pure noise at any $K$. The paper gives its own reason for caring about the schedule: it "controls the extent to which diffusion policy captures high and low-frequency characteristics of action signals", and the squared cosine schedule "works best for our tasks".

Generation runs the process backwards. Start from pure noise $\mathbf{x}^K$ and apply the trained network $K$ times. The paper writes one step as

with $\alpha$, $\gamma$ and $\sigma$ depending on $k$. The paper's $\alpha$ is a different quantity from the schedule's $\alpha_k$. In the notation of Ho et al., with $\alpha_k = \bar\alpha_k / \bar\alpha_{k-1}$, the same step reads

so the paper's symbols correspond to

and the paper's $\alpha$ is slightly larger than 1. Each step subtracts a scaled noise estimate, rescales, and adds a little fresh noise. The paper reads the step as noisy gradient descent on an energy $E$:

with $\boldsymbol{\epsilon}_\theta$ playing the role of $\nabla E$ and $\gamma$ the learning rate. The precise version of that reading is a standard identity: the noise predictor that minimizes the loss is a scaled score, the gradient of the log-density of the noised data,

so subtracting $\gamma\,\boldsymbol{\epsilon}_\theta$ moves the sample uphill in log-density, toward more likely data. Gradient ascent on a log-density plus injected Gaussian noise is Langevin dynamics, which is how the paper describes DDPM sampling; the NCSN explainer builds a sampler from exactly this idea. The score view returns in the section on training stability.

How Diffusion Policy works: denoising actions given observations

Two changes turn a DDPM into a policy. The sample $\mathbf{x}$ becomes $\mathbf{A}_t$, a sequence of $T_p$ future actions starting at control step $t$. And every call to the network also receives $\mathbf{O}_t$, the features of the latest $T_o$ observations. The reverse step becomes paper Eq. (4) and the loss paper Eq. (5):

The observations are inputs only. They are never noised and never generated, so the model learns the conditional distribution $p(\mathbf{A}_t \mid \mathbf{O}_t)$. The obvious alternative, used by Janner et al.'s Diffuser for planning, is to diffuse the joint distribution $p(\mathbf{A}_t, \mathbf{O}_t)$ of actions and observations over a trajectory. For a camera-based robot that would make the network generate future images at every denoising step. Conditioning instead means the image encoder runs once per decision, only the small action tensor goes through the denoising loop, and the encoder can be trained end to end with the policy.

Concrete shapes, from the state-based Push-T task in the official code. An observation is 20 numbers: 9 keypoints of the T-block in 2D plus the end-effector's 2D position. With $T_o = 2$, $\mathbf{O}_t$ is 40 numbers. An action is the 2D target position of the end-effector, and with $T_p = 16$, $\mathbf{A}_t$ is a 16 by 2 array, 32 numbers. The noise level enters as a 256-dimensional embedding, concatenated with the 40 observation numbers into one conditioning vector. One training step:

# one training step, state-based Push-T (shapes for one sample)
O, A0 = sample_window(demos)   # O: 2 x 20 observations, A0: 16 x 2 in [-1, 1]
k     = randint(1, 100)        # noise level, uniform
eps   = randn(16, 2)           # unit Gaussian noise, same shape as A0
Ak    = sqrt(abar[k]) * A0 + sqrt(1 - abar[k]) * eps     # equation (A)
cond  = concat(step_embed(k), O.flatten())               # 256 + 40 numbers
loss  = mse(eps_theta(Ak, cond), eps)                    # paper Eq. (5)
loss.backward(); opt.step()    # gradient reaches eps_theta (and the image
ema.update(eps_theta)          # encoder, in the vision version); EMA is evaluated

Before any of this, every action dimension is rescaled by its minimum and maximum over the training set to $[-1, 1]$. The paper explains why it does not use the usual zero-mean, unit-variance standardization: the sampler clips its prediction to $[-1, 1]$ at each iteration for stability, and standardized data has values outside that range, which the sampler could then never produce.

Figure 3 runs the sampler on the two-route task from Figure 1. The demonstrations are two routes of 16 waypoints each, left and right of a block, with a little variation around each. For data this simple the best possible noise predictor has a closed form (the posterior mean of a two-component Gaussian mixture), so the figure uses what a perfectly trained network would compute, on the paper's cosine schedule with $K = 100$. Press Play and watch three things: the teal sequence $\mathbf{A}^k$, the dotted line showing the clean sequence the network would predict from the current $\mathbf{A}^k$, and the two side bars, which give the posterior probability of each route.

On the default run (10 DDIM steps) the bars read 0.50 and 0.50 at $k = 100$, since pure noise says nothing about the route, and the dotted prediction runs straight through the block. At $k = 70$ the left route's probability is 0.39, at $k = 50$ it is 0.14, and by $k = 40$ it is below 0.01: the sample has committed to the right route, and the remaining steps refine its shape. Over the 40 fixed draws, 22 end on the left route and 18 on the right.

Now set the steps slider to 1. A single step from pure noise returns the predicted clean sequence at $k = 100$, which is the average of the two routes, and all 40 draws go through the block. With 2 steps, 8 of 40 still do; with 5, one does; with 10 or more, none. The paper names two sources of multimodality in the sampler: the random starting point $\mathbf{A}^K$, which selects a basin, and the noise added at each DDPM step, which lets samples move between basins. With DDIM only the first remains, and the route is a deterministic function of the starting noise.

Predict 16 actions, execute 8

The policy runs in a loop with three horizons. At control step $t$ it reads the latest $T_o$ observations, samples a sequence of $T_p$ actions, and executes the first $T_a$ of them without re-planning. Then it reads fresh observations and samples again. The remaining $T_p - T_a$ predicted actions are discarded. This is receding-horizon control, the scheme model-predictive controllers use. The CNN defaults (the paper's Table 7) are $T_o = 2$, $T_p = 16$, $T_a = 8$ for the robomimic tasks, Push-T and Kitchen; Block Push uses $T_o = 3$, $T_p = 12$, $T_a = 1$, and the real-world Push-T policy executes 6. In the code, the 16 predicted actions start at the older of the two observed steps, so the executed actions are indices 1 through 8, beginning at the current step.

Predicting a sequence buys two things over predicting one action per step. Consistency: a single-step policy with a multimodal output, like LSTM-GMM or BET, can draw consecutive actions from different modes and produce "jittery actions that alternate between the two valid trajectories"; a sequence sampled in one piece comes from one mode. Idle actions: teleoperators pause, which puts runs of identical position commands into the data, and single-step policies learn to reproduce the pause. The paper reports that BC-RNN and IBC "often get stuck in real-world experiments when the idle actions are not explicitly removed from training". A 16-step target sequence that starts inside a short pause also contains the motion after it, so the policy learns the pause together with the movement that ends it. The same design also absorbs latency: in simulation, Diffusion Policy kept its peak performance with up to 4 steps of added delay.

The execution horizon $T_a$ sets a trade-off. Small $T_a$ re-plans often and reacts quickly, but every re-plan is a new random draw, and near an ambiguous point successive draws can pick different routes. Large $T_a$ commits for longer but keeps executing a stale plan after the world changes; the delay before the robot sees a change averages about $(T_a - 1)/2$ steps. The top of Figure 4 is a toy rollout that shows both failure modes; the bottom is the paper's measurement.

At $T_a = 1$ the default toy rollout re-draws its route at every step while the end-effector is still near the middle, zigzags 7 times, and cuts into the block. At $T_a = 8$ it commits to one side and reacts to the moved target 2 steps after the move; at $T_a = 16$ the reaction takes 10 steps. The measured curves have the same shape. On Square, executing 1 action per decision loses 27% relative to the best setting and executing 128 loses 50%; on Push-T the losses are 10% and 22%. Both peak at 8, and the paper reports 8 as "optimal for most tasks that we tested". The paper also notes that the next sampling run can be warm-started from the previous prediction for smoother actions.

Why Diffusion Policy trains stably and IBC does not

IBC can represent multimodal actions as well, so the paper argues the case on training behavior. An implicit policy defines the action distribution through an energy:

The normalizer $Z(\mathbf{o},\theta)$ integrates $e^{-E}$ over every possible action and has no closed form. IBC trains with an InfoNCE loss, which is the negative log-likelihood of (6) with $Z$ replaced by a sum over $N_{\text{neg}}$ sampled negative actions $\tilde{\mathbf{a}}^j$:

The denominator is a Monte Carlo estimate of $Z$. If no negative lands in a region the model wrongly gives low energy, the sum underestimates $Z$ there, the loss never pushes the energy up in that region, and the spurious low-energy actions survive training. The paper cites this inaccuracy of negative sampling as the known cause of EBM training instability. Its Fig. 6 shows IBC's training error spiking and its evaluation success rate swinging through training; because of this, IBC's authors evaluate every checkpoint and report the best one, which on real hardware means running many candidate policies on the robot to pick one.

Diffusion Policy learns the score of the same distribution instead. Take the gradient of the log of (6) with respect to the action. The log of a ratio is a difference, and $Z$ depends on the observation and the parameters but not on $\mathbf{a}$, so its gradient with respect to $\mathbf{a}$ is zero:

The last step is (C) with the scale $\sqrt{1-\bar\alpha_k}$ absorbed. Neither the loss (5) nor the sampler (4) contains $Z$, so there is nothing to estimate by sampling negatives; the loss is a plain regression onto Gaussian noise. Figure 5 puts the two cases side by side on a one-dimensional action with two modes.

Raising $N_{\text{neg}}$ shrinks the wobble but does not remove it, and each negative costs one more energy evaluation per training example. Training instability shows in the paper's tables as a gap between the best checkpoint and the average of the last 10. On ToolHang with state inputs LSTM-GMM, which uses no negatives, scores 0.67 at best and 0.31 on average, and the transformer Diffusion Policy 1.00 and 0.87. The gap is not always small for Diffusion Policy: the CNN variant scores 0.68 and 0.46 on Transport with mixed-quality data, and the transformer 0.95 and 0.79 on Push-T. The paper's claim is that Diffusion Policy "appears significantly more stable to train" and that its best hyperparameters are "mostly consistent across tasks".

A check on a linear system

Section 4.5 of the paper runs the method on a case where the right answer is known. A linear system evolves as

and the demonstrations come from a linear feedback controller $\mathbf{a}_t = -\mathbf{K}\mathbf{s}_t$, for example the solution of a linear-quadratic regulator. (In this section $\mathbf{A}$ is the dynamics matrix, not an action sequence.) With $T_p = 1$, each state has exactly one demonstrated action, so a noisy action minus the true action is exactly the noise that was added. Writing the noise as $\sigma_k$ times a unit Gaussian, the optimal denoiser is

where $\sigma_k$ is the standard deviation of the noise at level $k$, and DDIM sampling converges to $\mathbf{a} = -\mathbf{K}\mathbf{s}$. For $T_p > 1$ the optimal prediction of the action $t'$ steps ahead is

because the noise terms $\mathbf{w}$ are zero in expectation. A one-dimensional example: $A = 1$, $B = 1$ (the action moves the state directly), $K = 0.5$, current state $s_t = 2$. The controller's next three actions are $-1$, $-0.5$, $-0.25$, since each action halves the remaining distance. To predict the second and third numbers from $s_t$ alone, the network has to know how the state responds to an action. The paper's conclusion is that cloning a state-dependent behavior as a sequence requires the learner to implicitly learn a task-relevant dynamics model, and that with a nonlinear plant or policy that prediction can become harder and multimodal again.

Architecture, visual encoder and inference speed

The equations above do not fix the architecture of $\boldsymbol{\epsilon}_\theta$. The paper builds two versions and recommends starting with the first.

The CNN version adapts the 1D temporal convolutional network from Diffuser: a U-Net whose convolutions run along the time axis of the action sequence, with the 2 action coordinates as input channels. Conditioning enters through FiLM (feature-wise linear modulation) in every convolution block. In the code, one vector (the noise-level embedding concatenated with the flattened observation features) goes through a small linear layer per block that outputs a scale and a bias for each channel, and the block computes scale * features + bias. The state-based configuration uses channel widths 256, 512 and 1024 and kernel size 5. The paper found the CNN works on most tasks with little tuning, but it "performs poorly when the desired action sequence changes quickly and sharply through time (such as velocity command action space)", which it attributes to the preference of temporal convolutions for low-frequency signals.

The transformer version comes from minGPT. The noisy actions are the input tokens, a sinusoidal embedding of $k$ is prepended as an extra token, and the observations pass through a shared MLP into a sequence of embeddings that the decoder attends to (cross-attention in the code, where the $k$ token joins the observation sequence). Each action token attends only to itself and earlier action tokens. Each output token is the noise estimate for its action. On state-based tasks most of the best results came from the transformer, especially when actions change quickly, but its best dropout and weight decay "varies greatly across different tasks". The paper's advice: start with the CNN and switch to the transformer if the task needs high-rate action changes.

The visual encoder is a ResNet-18 trained from scratch together with the policy, one encoder per camera, with two changes. Global average pooling is replaced by spatial softmax pooling: for each feature channel, a softmax over the image positions produces a probability map, and the channel outputs the expected x and y coordinate under that map, which keeps the location of each feature. And batch normalization is replaced by group normalization, which the paper calls "important when the normalization layer is used in conjunction with Exponential Moving Average". The paper does not spell out the mechanism. A plausible one: the evaluated model is an exponential moving average of the weights, while batch normalization's running statistics were accumulated under the live weights, and group normalization computes its statistics from each input and keeps no running state. On real Push-T, end-to-end training gave 95% success against 80% with an R3M-pretrained encoder and 15% with an ImageNet-pretrained one. In simulation on Square, fine-tuning a pre-trained encoder at a 10 times smaller learning rate did best, with a CLIP-trained ViT-B/16 at 98%, while a ViT trained from scratch reached 22%.

Inference speed comes from DDIM, which reuses a network trained with $K$ levels and samples it at a subset of them, deterministically. The paper's latency figure: "using DDIM with 100 training iterations and 10 inference iterations enables 0.1s inference latency on a Nvidia 3080 GPU", about 10 ms per network call. The reported benchmark numbers used other settings, according to Appendix A.4: the simulation results sample with all 100 iDDPM steps, and the real-world experiments use 16 DDIM steps. On the real robot the policy outputs commands at 10 Hz, which are linearly interpolated to 125 Hz for the arm's controller, and each decision executes 6 to 8 of the 10 Hz commands ($T_a = 6$ on real Push-T, 8 on the other real tasks). One decision:

# one decision at time t (T_o = 2, T_p = 16, T_a = 8)
O = last_observations(2)                # encoded once per decision
A = randn(16, 2)                        # A^K: pure noise
for k in schedule:                      # 100 DDPM steps, or 10 to 16 with DDIM
    eps_hat = eps_theta(A, concat(step_embed(k), O.flatten()))
    A = scheduler_step(A, eps_hat, k)   # paper Eq. (4); predicted A^0 clipped
execute(unnormalize(A[1:9]))            # 8 actions, from the current step on
# after 8 control steps: read 2 fresh observations and repeat

Why position control works better for Diffusion Policy

A robot arm can be commanded in two ways. Velocity control sends how fast, and in which direction, the end-effector should move over the next step; the low-level controller integrates that into a position. Position control sends the target position itself. Most behavior cloning work before this paper, including robomimic and BET, used velocity control. Diffusion Policy predicts positions, and the paper reports that this "consistently outperforms" the same method with velocity control. In the main benchmark each method used its own best action space: position for Diffusion Policy, velocity for the baselines.

Figure 6 is the paper's ablation (its Fig. 4). Each bar is the relative change in success rate when a method is switched from velocity to position control, on the robomimic Square task and on Franka Kitchen's p4 metric (the fraction of rollouts that complete 4 sub-tasks).

On Kitchen p4 the CNN Diffusion Policy's success rate goes up by 96% of its velocity-control value, close to doubling, while LSTM-GMM and BET lose 28% and 32%. On Square the changes are smaller: +20% and +7% for the two Diffusion Policy variants, −23% and −17% for the baselines.

The explanation is labeled as speculation in the paper, with two parts. First, "action multimodality is more pronounced in position-control mode": a target position several steps ahead depends on which route was chosen, which hurts the baselines, and Diffusion Policy handles multimodality better. Second, position control "suffers less than velocity control from compounding error effects". For a sense of scale: if each of 8 predicted velocity commands carries the same small bias $e$, the end-effector is off by $8e$ when the chunk finishes, while 8 position targets with the same bias are each off by $e$. The latency ablation fits this reading, since velocity control degraded more than position control under added delay.

Results and limitations

The paper evaluates 15 tasks from 4 benchmarks in simulation and the real world. The simulated suites are robomimic (Lift, Can, Square, Transport, ToolHang, with proficient-human "ph" data and, for four tasks, mixed-quality "mh" data), Push-T from IBC, Multimodal Block Pushing from BET, and Franka Kitchen from Relay Policy Learning. Each number is the average over 3 training seeds and 50 environment initializations (22 for robomimic, because of an evaluation bug the authors disclose), reported as the best checkpoint and as the average of the last 10 checkpoints. For each baseline the paper takes the best number available, whether its own reproduction or the original paper's.

The headline 46.9% is a mean of per-task relative improvements. For each simulated task, take the best Diffusion Policy variant (CNN or transformer) and the best baseline, both at their best checkpoint, and compute $(\text{ours} - \text{baseline}) / \text{baseline}$; mh results are left out, and the mean of those ratios is 0.46858. Individual terms vary widely. On ToolHang with state inputs the transformer variant scores 1.00 against LSTM-GMM's 0.67, an improvement of 49%. Lift and Can are solved by several methods (1.00 for LSTM-GMM, BET and Diffusion Policy), contributing 0%. Block Push's p2 metric improves by 32% and Kitchen's p4 by 213%, so a few hard tasks move the average most.

Simulated Push-T, scored by how much of the target area the T-block covers, gives (state inputs, best checkpoint) LSTM-GMM 0.67, IBC 0.90, BET 0.79, and 0.95 for both Diffusion Policy variants. With image inputs the numbers are LSTM-GMM 0.69, IBC 0.75, and 0.91 for the CNN variant.

On a UR5 arm doing a harder, two-stage Push-T (push the T into place, then move the end-effector to an end zone), trained on 136 demonstrations, Diffusion Policy reached 95% success and an IoU of 0.80 against the human demonstrators' 0.84 (IoU is the intersection over union between the T-block's final pose and the target region, measured in the top-down camera image). The best baselines reached 20% (LSTM-GMM) and 0% (IBC); LSTM-GMM got stuck near the block in 8 of 20 trials and IBC left the block early in 6 of 20. Mug flipping succeeded in 90% of 20 trials, where an LSTM-GMM policy failed to grasp in all of them. On sauce pouring and spreading, trained on 50 demonstrations each, coverage was 0.74 and 0.77 against human 0.79 and 0.79, while LSTM-GMM failed to lift the ladle in 15 of 20 pouring trials. The journal version adds three bimanual tasks, run "out of the box" without hyperparameter tuning: egg beating at 55% (210 demonstrations), mat unrolling at 75% (162) and shirt folding at 75% (284), each over 20 trials.

The paper lists two limitations. Diffusion Policy inherits behavior cloning's weaknesses, such as poor performance with too few demonstrations, and suggests reinforcement learning as a way to use suboptimal and negative data. And it has "higher computational costs and inference latency compared to simpler methods like LSTM-GMM", which action chunking only partly offsets and which "may not suffice for tasks requiring high rate control"; the authors point to newer noise schedules, faster solvers and consistency models to cut the number of sampling steps. A third practical constraint comes from the horizon ablation rather than the limitations section: the execution horizon trades consistency against reaction time, and 8 steps was the best value for most of the tasks the paper tested.