MP1: One-Step MeanFlow Robotic Policy

• MP1 is a one-step generative policy that learns interval-averaged velocities, bypassing iterative denoising and ODE integration for faster inference.
• It conditions on 3D point-clouds and robot state embeddings to generate accurate action trajectories in a single algebraic recovery step.
• Benchmarks show MP1 achieves high success rates and reduced inference times compared to diffusion and traditional flow-based policies.

Searching arXiv for the MP1 robotic manipulation paper and its direct follow-up to ground the article in current preprints. arXiv_search(query="MP1 Mean Flow Tames Policy Learning in 1-step for Robotic Manipulation", max_results=5) arXiv_search(query="OMP One-step Meanflow Policy with Directional Alignment", max_results=5) arXiv_search(query="MeanFlow generative model", max_results=5) MP1 is a one-step generative policy for robotic manipulation that adapts the MeanFlow paradigm to policy learning from 3D point-cloud observations. It learns interval-averaged velocities rather than relying on diffusion-style iterative denoising or flow-matching ODE integration, so that future action trajectories can be generated in one network function evaluation ($1$-NFE) without numerical ODE solves or explicit consistency constraints (Sheng et al., 14 Jul 2025). In the literature on manipulation policies, MP1 is therefore positioned as a MeanFlow-based, single-step alternative intended to resolve the speed–accuracy trade-off that had previously separated diffusion policies from faster but more structurally constrained flow methods (Fang et al., 22 Dec 2025).

1. Taxonomic position within generative manipulation policies

MP1 emerged in a setting where robot manipulation policies were increasingly formulated as conditional generative models. Diffusion policies offered expressive multimodal action generation, but required multi-step denoising and therefore incurred substantial sampling latency. Flow-based policies reduced that latency by learning continuous velocity fields, yet still depended on numerical ODE integration at test time and often introduced explicit consistency constraints. MP1 was proposed as a distinct alternative: it uses MeanFlow to learn interval-averaged velocities directly, thereby replacing iterative denoising and ODE integration with a single algebraic recovery step (Sheng et al., 14 Jul 2025).

Within the taxonomy of generative policy learning for manipulation, MP1 belongs to the MeanFlow-based, single-step family. In this framing it is adjacent to other one-step flow paradigms, but differs from them by not imposing explicit multi-segment or straight-flow consistency constraints. It is also distinct from diffusion-based policies such as DP and DP3, which require many denoising steps, and from FlowPolicy, which is single-step but relies on consistency flow matching and segmented training (Fang et al., 22 Dec 2025).

A recurrent point of clarification is that MP1 is not simply a fast approximation to a diffusion sampler. Its defining mechanism is the direct learning of interval-averaged velocity fields through the MeanFlow Identity, not the truncation of a multi-step denoising process. Likewise, it is not a conventional flow-matching model with a cheaper solver; its inference avoids numerical integration altogether.

2. MeanFlow formulation and policy architecture

The underlying MeanFlow construction begins with a trajectory $z(t)$ in latent or action space driven by an instantaneous velocity field $v(z,t)$. Standard flow matching uses the ODE

$\frac{dz(t)}{dt} = v(z(t), t),$

so sampling requires numerical integration from noise to data. MeanFlow instead defines the interval-averaged velocity over $[r,t]$ by

$$u(z_t, r, t) \triangleq \frac{1}{t-r}\int_{\tau=r}^{t} v(z_\tau,\tau)\,d\tau,$$

which satisfies the displacement relation $z_t-z_r=(t-r)u(z_t,r,t)$. The central identity used in MP1 is

$$u(z_t, r, t \mid c) = v(z_t, t \mid c) - (t-r)\,\frac{d}{dt}u(z_t, r, t \mid c),$$

with total derivative

$$\frac{d}{dt}u(z_t,r,t)=\partial_t u(z_t,r,t)+\partial_z u(z_t,r,t)\cdot v(z_t,t).$$

This identity is exact and is used to construct a regression target for the interval-averaged velocity field (Sheng et al., 14 Jul 2025).

For robotic manipulation, MP1 conditions this MeanFlow field on scene and robot context. The observation history is represented as $P \in \mathbb{R}^{n_o \times n_p \times 3}$, a sequence of $z(t)$0 point-cloud frames with $z(t)$1 points each, together with robot states $z(t)$2. The future trajectory is $z(t)$3, a $z(t)$4-step action sequence over the prediction horizon. Point clouds are reduced by farthest point sampling to $z(t)$5–$z(t)$6 points and encoded into a 3D visual embedding $z(t)$7; robot proprioception is encoded into a state embedding $z(t)$8. These are combined into conditional features $z(t)$9, which condition a UNet-integrated MeanFlow network $v(z,t)$0 (Sheng et al., 14 Jul 2025).

Training uses paired expert trajectories $v(z,t)$1 and Gaussian noise $v(z,t)$2, with interpolation along a probability path. In simulation, the paper reports $v(z,t)$3, observation window length $v(z,t)$4, and history length $v(z,t)$5 states; in the real-world study the horizon is $v(z,t)$6 with observation stride $v(z,t)$7 (Sheng et al., 14 Jul 2025).

3. Objectives, guidance, and regularization

The base MP1 objective is a regression loss derived from the MeanFlow Identity. Using the known instantaneous velocity $v(z,t)$8 of the probability path and stop-gradients for stability, the target averaged velocity is defined as

$v(z,t)$9

and the unguided loss is

$\frac{dz(t)}{dt} = v(z(t), t),$0

In the policy implementation, MP1 uses $\frac{dz(t)}{dt} = v(z(t), t),$1 and $\frac{dz(t)}{dt} = v(z(t), t),$2, so training and inference span the full interval from noise to expert trajectory (Sheng et al., 14 Jul 2025).

MP1 further incorporates classifier-free guidance (CFG) for controllability while retaining single-step inference. During training, conditional inputs are randomly dropped to obtain unconditional predictions, and the guided instantaneous velocity is

$\frac{dz(t)}{dt} = v(z(t), t),$3

with training objective

$\frac{dz(t)}{dt} = v(z(t), t),$4

The same paper notes that one may also use the familiar inference-time blending

$\frac{dz(t)}{dt} = v(z(t), t),$5

but MP1 primarily bakes guidance into training so that inference remains a single pass (Sheng et al., 14 Jul 2025).

A further component is the Dispersive Loss, introduced to preserve subtle scene-context differences in the embedding space, especially in few-shot settings:

$\frac{dz(t)}{dt} = v(z(t), t),$6

In the reported experiments, $\frac{dz(t)}{dt} = v(z(t), t),$7, the loss is applied to outputs of each UNet downsampling block, and the total objective is

$\frac{dz(t)}{dt} = v(z(t), t),$8

with $\frac{dz(t)}{dt} = v(z(t), t),$9 (Sheng et al., 14 Jul 2025). The paper explicitly distinguishes this from consistency losses: the Dispersive Loss regularizes the representation space rather than enforcing self-consistency across time or inputs.

4. One-step inference and deployment properties

At inference time, MP1 generates the entire action trajectory in one forward pass. Given point-cloud history $[r,t]$0 and robot states $[r,t]$1, the model encodes the conditioning features $[r,t]$2, samples noise $[r,t]$3, predicts the mean velocity over $[r,t]$4 as $[r,t]$5, and outputs

$[r,t]$6

Because $[r,t]$7, the update is purely algebraic. No denoising loop and no ODE solver are used, so the method avoids solver step-size sensitivity, stability issues, and cumulative discretization error (Sheng et al., 14 Jul 2025).

This inference structure is central to MP1’s deployment profile. The paper reports average inference time on an NVIDIA RTX 4090 GPU of $[r,t]$8 ms, compared with $[r,t]$9 ms for FlowPolicy and $$u(z_t, r, t) \triangleq \frac{1}{t-r}\int_{\tau=r}^{t} v(z_\tau,\tau)\,d\tau,$$0 ms for DP3 (Sheng et al., 14 Jul 2025). The reported interpretation is that MP1 is approximately $$u(z_t, r, t) \triangleq \frac{1}{t-r}\int_{\tau=r}^{t} v(z_\tau,\tau)\,d\tau,$$1 faster than DP3 and nearly $$u(z_t, r, t) \triangleq \frac{1}{t-r}\int_{\tau=r}^{t} v(z_\tau,\tau)\,d\tau,$$2 faster than FlowPolicy, while remaining at $$u(z_t, r, t) \triangleq \frac{1}{t-r}\int_{\tau=r}^{t} v(z_\tau,\tau)\,d\tau,$$3-NFE.

The training protocol used in the benchmark study is equally specific. Simulation experiments use $$u(z_t, r, t) \triangleq \frac{1}{t-r}\int_{\tau=r}^{t} v(z_\tau,\tau)\,d\tau,$$4 demonstrations per task, $$u(z_t, r, t) \triangleq \frac{1}{t-r}\int_{\tau=r}^{t} v(z_\tau,\tau)\,d\tau,$$5 epochs on Adroit, $$u(z_t, r, t) \triangleq \frac{1}{t-r}\int_{\tau=r}^{t} v(z_\tau,\tau)\,d\tau,$$6 epochs on Meta-World, evaluation every $$u(z_t, r, t) \triangleq \frac{1}{t-r}\int_{\tau=r}^{t} v(z_\tau,\tau)\,d\tau,$$7 epochs, and reporting by averaging the top-$$u(z_t, r, t) \triangleq \frac{1}{t-r}\int_{\tau=r}^{t} v(z_\tau,\tau)\,d\tau,$$8 success rates per seed over $$u(z_t, r, t) \triangleq \frac{1}{t-r}\int_{\tau=r}^{t} v(z_\tau,\tau)\,d\tau,$$9 random seeds. The real-world study uses an ARX R5 dual-arm robot with a RealSense L515 camera on five tasks—Hammer, Drawer Close, Heat Water, Stack Block, and Spoon—with $z_t-z_r=(t-r)u(z_t,r,t)$0 demonstrations (Sheng et al., 14 Jul 2025).

5. Benchmarks, task performance, and few-shot behavior

MP1 is evaluated on $z_t-z_r=(t-r)u(z_t,r,t)$1 manipulation tasks: Adroit Hammer, Door, and Pen, together with $z_t-z_r=(t-r)u(z_t,r,t)$2 Meta-World tasks partitioned as Easy $z_t-z_r=(t-r)u(z_t,r,t)$3, Medium $z_t-z_r=(t-r)u(z_t,r,t)$4, Hard $z_t-z_r=(t-r)u(z_t,r,t)$5, and Very Hard $z_t-z_r=(t-r)u(z_t,r,t)$6. In this evaluation, MP1 reports an average success rate of $z_t-z_r=(t-r)u(z_t,r,t)$7, versus $z_t-z_r=(t-r)u(z_t,r,t)$8 for FlowPolicy and $z_t-z_r=(t-r)u(z_t,r,t)$9 for DP3 (Sheng et al., 14 Jul 2025).

Method	Average success	Average inference time
MP1	$$u(z_t, r, t \mid c) = v(z_t, t \mid c) - (t-r)\,\frac{d}{dt}u(z_t, r, t \mid c),$$0	$$u(z_t, r, t \mid c) = v(z_t, t \mid c) - (t-r)\,\frac{d}{dt}u(z_t, r, t \mid c),$$1 ms
FlowPolicy	$$u(z_t, r, t \mid c) = v(z_t, t \mid c) - (t-r)\,\frac{d}{dt}u(z_t, r, t \mid c),$$2	$$u(z_t, r, t \mid c) = v(z_t, t \mid c) - (t-r)\,\frac{d}{dt}u(z_t, r, t \mid c),$$3 ms
DP3	$$u(z_t, r, t \mid c) = v(z_t, t \mid c) - (t-r)\,\frac{d}{dt}u(z_t, r, t \mid c),$$4	$$u(z_t, r, t \mid c) = v(z_t, t \mid c) - (t-r)\,\frac{d}{dt}u(z_t, r, t \mid c),$$5 ms

At the task level, MP1 achieves $$u(z_t, r, t \mid c) = v(z_t, t \mid c) - (t-r)\,\frac{d}{dt}u(z_t, r, t \mid c),$$6 on Adroit Hammer, $$u(z_t, r, t \mid c) = v(z_t, t \mid c) - (t-r)\,\frac{d}{dt}u(z_t, r, t \mid c),$$7 on Door, and $$u(z_t, r, t \mid c) = v(z_t, t \mid c) - (t-r)\,\frac{d}{dt}u(z_t, r, t \mid c),$$8 on Pen. On Meta-World it reports $$u(z_t, r, t \mid c) = v(z_t, t \mid c) - (t-r)\,\frac{d}{dt}u(z_t, r, t \mid c),$$9 on Easy, $$\frac{d}{dt}u(z_t,r,t)=\partial_t u(z_t,r,t)+\partial_z u(z_t,r,t)\cdot v(z_t,t).$$0 on Medium, $$\frac{d}{dt}u(z_t,r,t)=\partial_t u(z_t,r,t)+\partial_z u(z_t,r,t)\cdot v(z_t,t).$$1 on Hard, and $$\frac{d}{dt}u(z_t,r,t)=\partial_t u(z_t,r,t)+\partial_z u(z_t,r,t)\cdot v(z_t,t).$$2 on Very Hard. Relative to FlowPolicy, the reported gains are $$\frac{d}{dt}u(z_t,r,t)=\partial_t u(z_t,r,t)+\partial_z u(z_t,r,t)\cdot v(z_t,t).$$3 on Easy, $$\frac{d}{dt}u(z_t,r,t)=\partial_t u(z_t,r,t)+\partial_z u(z_t,r,t)\cdot v(z_t,t).$$4 on Medium, $$\frac{d}{dt}u(z_t,r,t)=\partial_t u(z_t,r,t)+\partial_z u(z_t,r,t)\cdot v(z_t,t).$$5 on Hard, and $$\frac{d}{dt}u(z_t,r,t)=\partial_t u(z_t,r,t)+\partial_z u(z_t,r,t)\cdot v(z_t,t).$$6 on Very Hard (Sheng et al., 14 Jul 2025).

The few-shot emphasis is integral rather than incidental. The benchmark regime typically uses $$\frac{d}{dt}u(z_t,r,t)=\partial_t u(z_t,r,t)+\partial_z u(z_t,r,t)\cdot v(z_t,t).$$7 demonstrations, and the ablation study reports that MP1 outperforms FlowPolicy across $$\frac{d}{dt}u(z_t,r,t)=\partial_t u(z_t,r,t)+\partial_z u(z_t,r,t)\cdot v(z_t,t).$$8 and $$\frac{d}{dt}u(z_t,r,t)=\partial_t u(z_t,r,t)+\partial_z u(z_t,r,t)\cdot v(z_t,t).$$9 demonstrations, with gains largest in few-shot regimes. Removing the Dispersive Loss reduces success across Adroit and Meta-World by approximately $P \in \mathbb{R}^{n_o \times n_p \times 3}$0–$P \in \mathbb{R}^{n_o \times n_p \times 3}$1 points on average, which the paper interprets as evidence that scene discrimination and representation geometry matter materially for low-data generalization (Sheng et al., 14 Jul 2025).

The same study reports a real-world evaluation in which MP1 achieves higher success and faster completion times across all five robot tasks. No per-task numeric table is given in the supplied summary, but the qualitative conclusion is consistent with the simulation results: MP1 combines single-step control with practically usable 3D conditioning.

6. Limitations and subsequent refinement

Although MP1 was introduced as a fast and comparatively simple one-step policy, subsequent work identifies several limitations in its training dynamics and derivative computation. A follow-up method, OMP, explicitly frames itself as improving MP1-style MeanFlow training (Fang et al., 22 Dec 2025).

One limitation concerns few-shot generalization under the Dispersive Loss. MP1 uses fixed temperature hyperparameters in this loss, and the follow-up analysis argues that this degrades few-shot generalization: a fixed temperature can under-disperse latent representations in low-data settings or over-disperse them in other regimes. A related limitation concerns directional learning. If $P \in \mathbb{R}^{n_o \times n_p \times 3}$2 is the predicted velocity and $P \in \mathbb{R}^{n_o \times n_p \times 3}$3 the target, then

$P \in \mathbb{R}^{n_o \times n_p \times 3}$4

with angle gradient

$P \in \mathbb{R}^{n_o \times n_p \times 3}$5

When the true velocity magnitude is small, $P \in \mathbb{R}^{n_o \times n_p \times 3}$6, the angular correction vanishes. The later paper diagnoses this as a specific failure mode for MP1-style MeanFlow training in high-precision, low-velocity regimes, where directional errors may persist because MSE couples direction learning to magnitude (Fang et al., 22 Dec 2025).

A further critique concerns the relationship between instantaneous and interval-averaged velocities. MP1’s target construction uses a model for instantaneous velocity $P \in \mathbb{R}^{n_o \times n_p \times 3}$7, while the network is trained to predict interval-averaged velocity $P \in \mathbb{R}^{n_o \times n_p \times 3}$8. The follow-up work describes this as a conceptual and practical mismatch that can manifest as misalignment between the predicted interval-averaged velocity and the true mean velocity

$P \in \mathbb{R}^{n_o \times n_p \times 3}$9

It also notes that computing the MeanFlow target via Jacobian-Vector Products (JVPs) incurs high GPU memory consumption in MP1 (Fang et al., 22 Dec 2025).

OMP addresses these issues by adding a cosine-based directional term,

$z(t)$00

and by replacing JVP-based derivatives with a Differential Derivation Equation finite-difference approximation. In the reported comparison on Adroit and Meta-World with the same $z(t)$01-demonstration protocol, OMP attains $z(t)$02 average success rate versus $z(t)$03 for MP1, with especially strong gains on Meta-World Medium $z(t)$04, Hard $z(t)$05, and Very Hard $z(t)$06 (Fang et al., 22 Dec 2025).

This later evaluation does not diminish MP1’s original role; rather, it clarifies it. MP1 remains the formulation that established MeanFlow as a viable one-step policy for 3D robotic manipulation, demonstrating that interval-averaged velocity learning can outperform both diffusion and consistency-flow baselines while retaining real-time performance. The subsequent refinements suggest that MP1 is best understood as a foundational MeanFlow policy whose principal open issues are directional alignment, temperature sensitivity in representation regularization, and the training-time cost of derivative estimation.