Most robot policies, whether trained by imitation learning (IL) or reinforcement learning (RL), map observations to action values at discrete control steps and leave the continuity of physical motion to be learned implicitly. We propose ODE policy, which learns the dynamics of the action rather than the action itself. A neural ordinary differential equation (ODE) learns the vector field of the action by matching the integrated actions to the targets over short action chunks in IL and single control steps in RL. A lightweight diversity head captures multi-modal behavior by randomizing the direction of the field. At deployment, each action is integrated from the previous one, so the executed trajectory is continuous by construction.

We evaluate it as a visuomotor policy, as the action head of vision-language-action (VLA) and world action models (WAMs), and as the actor of model-based RL against 14 baselines on unimanual, bimanual, dexterous, locomotion, and loco-manipulation tasks. In IL, against flow matching, it reaches 5.9\times the success, 5.4\times the generalization, and 3.9\times the mode balance after one epoch, and generates actions 10.8\times faster. It mostly moves more smoothly than human demonstrations. On 14 real-world tasks across single-arm, dual-arm, dexterous, and humanoid robots, it achieves the highest success rate. In RL, it further speeds up SuperMimic for humanoid motion tracking and smooths its actions. Efficient in learning, data, parameters, and execution, ODE policy offers a promising path to scaling robot learning.

Robot learning has advanced rapidly in the past few years. In imitation learning (IL), visuomotor policies (Chi et al., 2025; Zhao et al., 2023), vision-language-action (VLA) models (Zitkovich et al., 2023; Kim et al., 2025; Black et al., 2024; Physical Intelligence et al., 2025; Bjorck et al., 2025), and world action models (WAMs) (Zhang et al., 2026; An et al., 2026; Hou et al., 2026) now perform a wide range of manipulation tasks. In reinforcement learning (RL), actors trained in massively parallel simulation let legged and humanoid robots walk and track human motions (Rudin et al., 2022; Mittal et al., 2023; Liao et al., 2026b). Despite their differences, most of these policies follow the same paradigm. They encode the history of observations and the proprioceptive state, and map it directly to future actions at discrete time steps.

This paradigm has limits in both settings. In IL, it relies on large-scale data and compute to generalize. Yet robot data are heterogeneous in embodiment, quality, and control interface, and cannot be collected at the scale of internet data. Training large foundation policies is also costly. Generative policies (Chi et al., 2025; Black et al., 2024) further need multiple network evaluations for each chunk. They react to new observations only after the whole chunk is produced, which limits real-time execution (Black et al., 2025; Bai et al., 2026; Jia et al., 2026c).

In RL, the policy must gather experience from a large number of interactions (Rudin et al., 2022). Without explicit regularization, its actions often oscillate at high frequency. This wastes control effort, wears the actuators, and hurts the transfer from simulation to reality (Mysore et al., 2021; Raffin et al., 2022; Peng et al., 2020). A novel robot policy paradigm that is efficient in learning, data, parameters, and execution, and especially amenable to scaling, is therefore needed.

A robot is a macroscopic classical system that moves continuously in time. The actions that command it, e.g., those teleoperated by humans, are largely continuous as well. A demonstration is therefore largely a sampling of a continuous action trajectory at the control frequency. Direct-action policies must learn this continuity implicitly from data. At chunk boundaries, it is not even guaranteed, and the commands jump (Black et al., 2025). An ordinary differential equation (ODE) (Chen et al., 2018) naturally describes such continuous change. Applied to the action, an ODE can model its dynamics, a law of motion shared by every step. Integrating it yields a continuous action trajectory by construction.

Notably, animal motor cortex is thought to generate movement through such dynamics rather than by encoding its target (Churchland et al., 2012; Shenoy et al., 2013). ODEs have long described robot motion (Ijspeert et al., 2013; Bahl et al., 2020). However, they fix the form of the vector field or force it to converge to an attractor. Each model is thus limited to a few motions.

In this work, we propose ODE policy. It learns the dynamics of the action rather than the action itself, i.e., it models the policy directly as an ODE (Fig. 2). Concretely, a neural ODE (Chen et al., 2018) learns the vector field of the action, conditioned on the observation. The action is then integrated over the physical time of the robot. Integrating over a whole demonstration accumulates drift and requires the costly adjoint method. In IL, we therefore integrate over action chunks (Chi et al., 2025; Zhao et al., 2023), a key to current direct-action policies (Pan et al., 2026; Lazzati et al., 2026), and supervise the integrated path without any derivative of the actions.

A contractive perturbation shifts the start of each training chunk and teaches the field to return, which improves robustness. In RL, we integrate over single control steps. At inference, each action is integrated from the previous one, across chunk boundaries in IL and across control steps in RL. Direct-action policies, in contrast, often jump or pause at chunk boundaries in IL and oscillate between steps in RL. Finally, a lightweight diversity head adds a sampled offset to the vector field to retain multi-modal behavior (Chi et al., 2025; Jia et al., 2026a).

We validate ODE policy across the mainstream IL models and in RL (Fig. 1). We instantiate it as a visuomotor policy, as the action expert of the \pi_{0.5} VLA (Physical Intelligence et al., 2025), as the action head of the ImageWAM (Zhang et al., 2026) WAM, and as the actor of SuperMimic (Liao et al., 2026a) for whole-body motion tracking of a humanoid. We further deploy it on a real single-arm robot, a dual-arm robot, a robot with dexterous hands, and a humanoid, where it replaces the action head of GR00T N1.7 (Bjorck et al., 2025). The real-robot tasks include high-precision, long-horizon, deformable, multi-modal, dexterous, and loco-manipulation tasks. We compare with 14 state-of-the-art baselines, including generative and regression-based IL methods. Within each setting, all methods share the same backbone, data, and training schedule.

Experiments show that ODE policy learns remarkably fast. After one epoch, it succeeds in 79.2% of the LIBERO episodes, against at most 43.2% for the baselines. As the action head of \pi_{0.5}, it succeeds in 96.0% against 75.5% for its flow matching expert. As that of ImageWAM, it succeeds in 82.6% against 24.6% for the original head. It matches flow matching with less than half of the demonstrations. As the actor of SuperMimic, it reaches a higher return early in training. On 14 tasks across single-arm, dual-arm, dexterous, and humanoid robots, it achieves the highest success rate on every task.

It also generates actions fast and smoothly. A chunk takes 10.8 times less time than with flow matching in simulation, and 3.5 to 27 times less than with the diffusion and flow matching baselines on real robots. On real robots, its motion is smoother than the human demonstrations in most cases. Moreover, it generalizes robustly to unseen perturbations in simulation, and it transfers dexterous skills learned from public data of another lab to our real robot. It also keeps multi-modal behavior, both on a navigation task and on a real bimanual task, where it uses both arm assignments. Finally, the learned field supports data without action labels and arbitrary control rates.

Action dynamics as ODEs. Representing robot motion as a dynamical system has a long history, from dynamical movement primitives (Ijspeert et al., 2013) and stable dynamical systems (Khansari-Zadeh and Billard, 2011) to neural vector fields with contraction or stability guarantees (Beik-Mohammadi et al., 2024; Sochopoulos et al., 2024). Neural dynamic policies (Bahl et al., 2020; Totsila et al., 2023) further predict the parameters of such systems from images. However, the fixed form or the stability constraint limits each system to a few motions toward an attractor, mostly on single tasks. ODE policy instead places no structural constraint on the vector field and learns one field for large-scale tasks.

State dynamics as ODEs. A conventional paradigm in robot learning is to learn the state dynamics of the robot or its environment and then design a policy or analytical controller upon it. Learned dynamics, often in the form of neural ODEs, are used for model-based reinforcement learning (Yildiz et al., 2021) and for feedback controllers that compensate for model uncertainty (Jia et al., 2025b; Jia et al., 2025a; Jia et al., 2026b). Continuous-time networks (Hasani et al., 2022) likewise evolve the hidden state of a policy by an ODE. In these works, the ODE describes the state of the system or of the network, and the action is still produced by a separate controller or output layer. ODE policy instead learns the ODE of the action itself.

Generative processes as ODEs. Diffusion and flow matching policies (Chi et al., 2025; Black et al., 2024) integrate over a generation time without physical meaning. Streaming flow policy (Jiang et al., 2025) aligns the flow time with the execution time, but it is still trained by regressing velocities derived from the demonstrations and regenerates each chunk over a rescaled time interval. Chronos policy (Wang et al., 2026) encodes the physical times of observations and actions in a diffusion transformer, but time remains an input, and actions are still generated at a fixed rate. In contrast, ODE policy integrates over physical time itself, is trained through the integrated path without velocity labels, and continues each chunk from the previous one.

Predicting a chunk of actions per observation was popularized by action chunking transformer (ACT) (Zhao et al., 2023) and diffusion policy (Chi et al., 2025), and is now standard in large foundation models (Black et al., 2024; Physical Intelligence et al., 2025; Bjorck et al., 2025). Recent analyses show that chunking is a key factor in the performance of current IL policies (Lazzati et al., 2026; Pan et al., 2026). Executing a chunk open-loop often outperforms updating the action at every observation (Park, 2026), which contrasts with the classical control experience that a higher closed-loop rate is better. However, independently predicted chunks may be inconsistent at their boundaries, which is mitigated by temporal ensembling (Zhao et al., 2023) or by conditioning each chunk on the committed actions of the previous one (Black et al., 2025).

ODE policy also builds on chunking for IL, but uses the chunk as the unit of integration. During training, it integrates the vector field over one chunk, so the gradient passes through a few solver steps without the adjoint method. At inference, it integrates each action from the previous one, which keeps the actions continuous across chunks and executes each action without waiting for a whole chunk. Some policies predict actions relative to the current pose (Chi et al., 2024), but still output each action of a chunk as a separate value. In ODE policy, all actions of a chunk follow from one vector field evaluated along the path.

Efficient IL policies. Generative policies require multiple network evaluations per chunk. Consistency models (Song et al., 2023; Zhang et al., 2025), self-distillation (Li et al., 2026), and mean flows (Geng et al., 2025; Fang et al., 2025) reduce the sampling to one or a few steps, and informed source distributions shorten the transport path (Scholz and Turner, 2025; Dai et al., 2026). VITA (Gao et al., 2026), action-to-action flow matching (A2A) (Jia et al., 2026c; Zuo et al., 2026), and FLASH (Bai et al., 2026) further replace the flow source with image observations or historical actions, which improves both learning efficiency and inference speed. These methods improve the efficiency of IL within the conventional direct-action paradigm. ODE policy instead changes the paradigm to an ODE, which exploits the inherent continuity of physical motion to improve efficiency.

Efficient RL policies. In RL, sample efficiency is mostly improved on the side of the critic and the update, e.g., by high update-to-data ratios with ensembled or regularized critics (Chen et al., 2021b; Hiraoka et al., 2022; Bhatt et al., 2024), scaled networks (Lee et al., 2025; Kim et al., 2026), or learned world models (Hansen et al., 2024). SuperMimic (Liao et al., 2026a) learns a differentiable world model and trains the actor by backpropagating analytic gradients through short imagined rollouts. It surpasses a state-of-the-art motion tracker after 3 hours on one GPU with more than 1000 times fewer GPU hours. These methods keep the actor as a direct map from states to actions. ODE policy instead changes the actor itself, and further speeds up SuperMimic as a drop-in replacement of its actor.

This section first formalizes the direct-action policies that ODE policy replaces, in both IL and RL, and then introduces the neural ODE on which ODE policy is built.

Let \mathbf{o}_t\in\mathcal{O} denote the visual observation in the image space \mathcal{O}, \mathbf{s}_t\in\mathbb{R}^{d_s} the proprioceptive state, and \mathbf{a}_t\in\mathbb{R}^{d_a} the action sent to the low-level controller at control step t\in\mathbb{N}, where d_s,d_a\in\mathbb{N} are the state and action dimensions. We write \mathbf{c}_t=(\mathbf{o}_t,\,\mathbf{l}_t) for the condition, with a language instruction \mathbf{l}_t\in\mathcal{T} in the space of instruction texts \mathcal{T}. The observation and the state usually include a short history. A conventional policy maps the condition and the state to the action value at each control step, where each action is predicted as a separate value. The model imposes no relation between consecutive actions. Any such relation, such as the continuity of the motion, must be learned implicitly from data. We call such policies direct-action policies, since the network outputs the action values themselves.

IL policies. IL fits \boldsymbol{\pi} to a dataset \mathcal{D} of N\in\mathbb{N} demonstrated trajectories \{(\mathbf{o}_t,\mathbf{s}_t,\mathbf{l}_t,\mathbf{a}_t)\}. Most IL policies follow action chunking (Zhao et al., 2023; Chi et al., 2025) and predict a chunk of H\in\mathbb{N} future actions at once, with \mathbf{A}_t\in\mathbb{R}^{H\times d_a}, which is executed before the next observation is processed. Each action \mathbf{a}_{t+k} with k\in\{0,\dots,H-1\} is still a separate value, within and across chunks, and H=1 recovers Eq. (1). Explicit regression maps (\mathbf{c}_t,\mathbf{s}_t) directly to \mathbf{A}_t under an \ell_1 or \ell_2 loss (Pomerleau, 1989; Zhao et al., 2023), which is simple but averages multi-modal demonstrations. Generative policies instead sample \mathbf{A}_t from a learned distribution. Diffusion policies (Chi et al., 2025; Ho et al., 2020) iteratively denoise a chunk drawn from Gaussian noise, and flow matching policies (Lipman et al., 2023; Liu et al., 2023b; Black et al., 2024; Jia et al., 2026c) integrate a deterministic vector field that transports a source sample to \mathbf{A}_t over a time \tau\in[0,1].

Notably, although diffusion and flow matching solve a differential equation at inference, \tau is a generation time without physical meaning. The intermediate sample is not a state the robot can occupy, and each chunk is generated anew, independently of where the previous chunk ended.

RL policies. RL instead trains \boldsymbol{\pi} through interaction to maximize the expected discounted return. Without images, \mathbf{s}_t holds the state history, and for motion tracking the condition \mathbf{c}_t holds the reference motion. The actor typically outputs a single action at each control step as in Eq. (1). Model-based methods such as SuperMimic (Liao et al., 2026a) update the actor by backpropagating the return of rollouts imagined in a differentiable world model.

A neural ODE (Chen et al., 2018; Jia et al., 2025b) parameterizes the time derivative of a continuous state \mathbf{x}(t)\in\mathbb{R}^{n}, n\in\mathbb{N}, at time t\in\mathbb{R} with a neural network \mathbf{g}_\phi:\mathbb{R}^{n}\times\mathbb{R}\to\mathbb{R}^{n} with parameters \phi, and obtains its trajectory from t_0 to t_1 (t_0,t_1\in\mathbb{R}, t_0<t_1) by integration, where the integral is evaluated by a numerical solver (e.g., the Euler method or Runge–Kutta methods such as RK2 and RK4) and the network is trained by back-propagating a loss on the integrated states.

The gradient is obtained either directly through the solver steps or by the adjoint method (Chen et al., 2018), which integrates an augmented ODE backward in time with constant memory at the cost of additional integration. The network only specifies the local rate of change, while the continuity and smoothness of the trajectory come from integration. Earlier robot policies built on dynamical systems, such as movement primitives (Ijspeert et al., 2013), stable dynamical systems (Khansari-Zadeh and Billard, 2011), and neural dynamic policies (Bahl et al., 2020), fix the form of the vector field in advance and learn only its parameters. In this work, we instead let the network itself be the vector field of the action, integrated over the physical time of the robot.

In this section, we propose ODE policy, which models how the action evolves over the physical time of the robot as an ODE (Fig. 2). We present it mainly for IL. We first formulate the policy as a vector field of the action (Section 4.1), then describe how it is trained from demonstrations (Section 4.2) and executed at inference (Section 4.3). Section 4.4 adds an optional diversity head for multi-modal behavior. Finally, Section 4.5 describes how the same field serves as the actor in RL.

Vector field. We encode the image history and the instruction into an embedding \mathbf{z}_t\in\mathbb{R}^{d_z}, d_z\in\mathbb{N}, and parameterize the velocity of the action with a neural network (Chen et al., 2018), where \mathbf{f}_\theta:\mathbb{R}^{d_a}\times\mathbb{R}^{d_s}\times\mathbb{R}^{d_z}\to\mathbb{R}^{d_a}, t\in\mathbb{R}_{\ge0} is the physical time of the robot in units of control steps, \mathbf{a}(t)\in\mathbb{R}^{d_a} is an action the robot is commanded to reach and \dot{\mathbf{a}} is its velocity. The proprioception \mathbf{s}_t enters the field directly rather than being encoded into \mathbf{z}_t together with \mathbf{c}_t as in conventional policies (ablated in Section 8).

Chunked integration. At a decision step t, the policy computes \mathbf{z}_t once and holds \mathbf{z}_t and \mathbf{s}_t fixed over the chunk. Starting from the last action \hat{\mathbf{a}}_{t-1}\in\mathbb{R}^{d_a}, it integrates Eq. (4) with a numerical solver, where t'\in\mathbb{R} is the integration variable, and we obtain the chunk \hat{\mathbf{A}}_t=[\hat{\mathbf{a}}_{t},\dots,\hat{\mathbf{a}}_{t+H-1}]\in\mathbb{R}^{H\times d_a} at the same steps as \mathbf{A}_t in Eq. (2). In contrast to Eqs. (1) and (2), each action is obtained from the previous one by integrating its rate of change, so consecutive actions are related by construction.

Notably, the field takes the current action \mathbf{a}(t) as input, so the change at each step depends on where the action has arrived. A conventional policy instead outputs the actions or increments of a chunk as H separate values, whose relation must be learned from data. Holding the condition fixed matches action chunking (Zhao et al., 2023; Chi et al., 2025), where the observation is processed once per chunk (Lazzati et al., 2026).

Note that the integrated state is the desired action, i.e., the target sent to the low-level controller, rather than the measured state of the robot. Since the low-level controller, e.g., a proportional-derivative (PD) or operational space controller (Khatib, 1987), tracks its target imperfectly, the robot state always lags behind the target (Zhao et al., 2026). For a delta controller (Zhu et al., 2020), the desired action is the current pose plus the scaled command, from which the command is recovered exactly at execution. When only the measured state is available, e.g., data collected by UMI (Chi et al., 2024) or from human videos (Kareer et al., 2026), we discuss how the velocity of the field naturally compensates for the lag in Section 9.

Path loss. Given a demonstration segment, we start from the demonstrated action \mathbf{a}_{t-1}, integrate Eq. (5) for H steps, and match the integrated path, Since the chunk is usually short, the gradient is back-propagated directly through the solver steps without the adjoint method (Chen et al., 2018). The field is supervised only through the integrated path and never regressed against velocity labels as in Jiang et al. (2025), which may amplify the jitter of noisy demonstrations.

Contractive perturbation. The path loss supervises the vector field only along the demonstrated trajectories. At execution, however, the policy integrates from its own previous output, so any error carries over to the next step and the next chunk, and the state gradually leaves the demonstrations. To improve robustness, we perturb the start point of a segment during training and require the integrated path to return to the demonstration, where \hat{\mathbf{a}}_{t+k}(\cdot) denotes the path of Eq. (5) integrated from the given start point, \boldsymbol{\delta}\in\mathbb{R}^{d_a} is the perturbation with scale \boldsymbol{\sigma}_\delta\in\mathbb{R}^{d_a}_{>0}, and \rho\in(0,1) is a decay rate. Each segment is perturbed with probability p\in[0,1], and \boldsymbol{\delta}=\mathbf{0} otherwise, which recovers Eq. (6).

Since the target deviation \rho^{k+1}\boldsymbol{\delta} shrinks geometrically, the field learns to pull nearby states back to the demonstration at a rate set by \rho, i.e., a local contraction (Beik-Mohammadi et al., 2024) around the demonstrations. We therefore call it contractive perturbation. It relies on the field taking the action as input. Standard direct-action policies do not take the commanded action as input, so such a perturbation has no counterpart for them. The perturbation requires neither additional data nor additional computation at inference (ablated in Fig. 17(A)).

The losses above are defined on a single demonstration segment \xi_t=(\mathbf{c}_t,\mathbf{s}_t,\mathbf{a}_{t-1:t+H-1}). The total objective averages them over the segments in \mathcal{D} and the perturbations, which is minimized over mini-batches of segments, where the optional diversity loss \mathcal{L}_{\text{div}} is introduced in Section 4.4. Algorithm 1 contrasts this training with that of a direct-action policy.

At inference, each action within a chunk is obtained from the previous one by a single integration step (Algorithm 2). Across chunks, we use seamless chunking, i.e., each chunk is integrated with Eq. (5) from the last action of the previous one, \hat{\mathbf{a}}_{t-1}, rather than from the measured state (ablated in Fig. 17(B, C)). This inference gives three benefits over direct-action policies.

(i) Smooth execution. Unlike independently generated chunks (Zhao et al., 2023; Black et al., 2025), successive chunks join without jumps, so the executed trajectory is a single integral curve whose condition is refreshed every H steps. (ii) Streaming execution. Each action is sent to the controller as soon as it is integrated, whereas direct-action policies must generate the whole chunk before executing its first action. (iii) Free integration step. Since the field is defined in continuous time, the integration step can be chosen at deployment, e.g., to match a higher control rate, whereas direct-action policies output actions at the fixed step of their training data (Fig. 19(C)).

Multi-modal behavior means that several distinct actions are valid in the same situation, e.g., passing an obstacle on the left or on the right (Chi et al., 2025; Jia et al., 2026a; Ma et al., 2026). A deterministic field \mathbf{f}_\theta fits the mean velocity of the demonstrations and thus averages such modes, e.g., heading straight into the obstacle (Fig. 3(A)).

Since the policy is a vector field, a mode is decided by the direction in which the integration sets off, and randomizing this direction is a natural way to select a mode. We therefore keep the ODE and add a lightweight diversity head \mathbf{h}_\psi with parameters \psi, which steers each chunk toward one mode by a sampled velocity offset (Fig. 3(B, C)). At the start of a chunk, \mathbf{h}_\psi reads the hidden features of \mathbf{f}_\theta with the gradient stopped and outputs a direction and a scale. The direction is an offset \boldsymbol{\epsilon}\in\mathbb{R}^{d_a} drawn from a K-component (K\in\mathbb{N}) Gaussian mixture (Bishop, 1994), whose components j\in\{1,\dots,K\} cover the modes with weights w_j\in[0,1] summing to one, means \boldsymbol{\mu}_j\in\mathbb{R}^{d_a}, and standard deviations \boldsymbol{\sigma}_j\in\mathbb{R}^{d_a}_{>0}. The scale is a non-negative rate \boldsymbol{\lambda}_k\in\mathbb{R}^{d_a}_{\ge0} for each step k=0,\dots,H-1. The chunk is then integrated with the added velocity, where \odot denotes the element-wise product.

Since \boldsymbol{\epsilon} is fixed over the chunk and each step lasts one control step, integrating the added velocity shifts the path at step k by about \boldsymbol{\Lambda}_k\odot\boldsymbol{\epsilon} with \boldsymbol{\Lambda}_k=\sum_{i=0}^{k}\boldsymbol{\lambda}_i\in\mathbb{R}^{d_a}_{\ge0}, and \boldsymbol{\epsilon}=\mathbf{0} recovers the plain ODE. The head should thus produce shifts that match how the demonstrations deviate from the plain path.

Diversity loss. To this end, let \mathbf{e}_k=\mathrm{sg}(\mathbf{a}_{t+k}-\hat{\mathbf{a}}_{t+k})\in\mathbb{R}^{d_a} denote the deviation of the demonstration from the plain path at step k, where \mathrm{sg} stops the gradient. The scale \boldsymbol{\Lambda}_k is fitted by the Gaussian negative log-likelihood of \mathbf{e}_k, and the mixture by the likelihood of the offset that best explains the deviation, \boldsymbol{\epsilon}^{*}=\arg\min_{\boldsymbol{\epsilon}}\sum_{k}\|\mathbf{e}_k-\boldsymbol{\Lambda}_k\odot\boldsymbol{\epsilon}\|_2^2. Since the problem decouples per dimension, it has the closed form \boldsymbol{\epsilon}^{*}=\big(\sum_{k}\boldsymbol{\Lambda}_k\odot\mathbf{e}_k\big)\oslash\big(\sum_{k}\boldsymbol{\Lambda}_k\odot\boldsymbol{\Lambda}_k\big), where \oslash denotes the element-wise division. The diversity loss is then where \log is applied element-wise, \mathbf{1}\in\mathbb{R}^{d_a} is the all-ones vector, and \mathcal{N}(\cdot;\boldsymbol{\mu},\boldsymbol{\Sigma}) is the Gaussian density. Since both its input and its target are detached, the head leaves the gradient of \mathbf{f}_\theta unchanged.

When to use it. When the same observation is followed by distinct actions in the demonstrations, the diversity head preserves these modes (Section 6.4). However, such strong multi-modality, with clearly distinct actions, occurs in only a small part of robot tasks. On LIBERO, for example, the actions for the same observation differ only slightly. Without the head, ODE policy still learns efficiently and reaches 85.3% after one epoch (Table S8), possibly because regression can already produce slight multi-modal behavior with a sufficient Lipschitz constant (Pan et al., 2026). For completeness and a fair comparison, all our IL experiments nevertheless use the head, sampling \boldsymbol{\epsilon} within the drawn component on the multi-modal tasks and using the component mean \boldsymbol{\mu}_j elsewhere (ablated in Appendix B.8).

The same field also serves as the actor in RL. Without demonstrations, the losses above are not used. The actor acts at every control step (H=1) and takes one Euler step from the previous action, i.e., Eq. (5) with H=1 and one Euler step, where \mathbf{z}_t embeds the reference motion \mathbf{c}_t instead of the images. The field is trained through this step by the objective of the RL algorithm, while the critic and the algorithm stay unchanged.

This step changes how the gradient flows in SuperMimic, which backpropagates the return through 32 imagined steps. Since \partial\hat{\mathbf{a}}_t/\partial\hat{\mathbf{a}}_{t-1} contains the identity, the gradient reaches early actions along the chain of actions without decay (measured in Section 6.1.3).

We evaluate ODE policy on four questions. (1) Does it learn faster and from less data than conventional direct-action policies? (2) Does it generate actions faster and more smoothly? (3) Does it generalize robustly to unseen perturbations? (4) Can it represent multi-modal behavior? Section 6 answers them in simulation, Section 7 verifies these advantages on four real robots, and Section 8 ablates each component of ODE policy. This section describes the setup shared by all three.

Benchmarks. For visuomotor IL, we train one model on the four LIBERO suites (Liu et al., 2023a) and test its generalization zero-shot on LIBERO-plus (Fei et al., 2025). As the action head of a VLA and a WAM, we fine-tune \pi_{0.5} (Physical Intelligence et al., 2025) and ImageWAM (Zhang et al., 2026) on the same suites and test them on LIBERO and on a shared set of LIBERO-plus instances. Multi-modality is tested on a 2D navigation task with four routes.

On a Franka Research 3 arm, a dual-arm Galaxea R1 Lite, a Sharpa North robot with Sharpa dexterous hands, and a Unitree G1 humanoid with Inspire DFX dexterous hands, we test 14 tasks that are high-precision, long-horizon, deformable, multi-modal, dexterous, or loco-manipulation, three of them trained on data from another lab. For RL, we replace the actor of SuperMimic (Liao et al., 2026a), which tracks the 40 LAFAN1 motion clips (Harvey et al., 2020) with a simulated Unitree G1 humanoid. Details of all benchmarks are given in Appendix A.

Baselines. For IL, we compare with six visuomotor policies that differ only in the action head, namely flow matching (Lipman et al., 2023) with a DiT (Peebles and Xie, 2023) or a 1D UNet head (FM-DiT and FM-UNet), diffusion (Ho et al., 2020; Chi et al., 2025) with the same two heads (DDPM-DiT and DDPM-UNet), A2A with a DiT head (A2A-DiT) (Jia et al., 2026c), and ACT (Zhao et al., 2023). All of them share the image and language encoder and have about 24M parameters outside it. On the real robots, the baselines are drawn from FM-DiT, DDPM-UNet, and the same UNet sampled in 16 DDIM steps (Song et al., 2021) (DDIM-UNet), with A2A-DiT added on the single-arm robot. On the humanoid, the baseline is the original action head of GR00T N1.7 (Bjorck et al., 2025). On the navigation task, we add MARS (Jia et al., 2026a), a policy with adaptive multi-modal ability.

In \pi_{0.5}, we compare with its original flow matching action expert, initialized either from the pretrained weights of \pi_{0.5} (FM) or randomly (FM-R). In ImageWAM, we compare with its original flow matching head and an A2A head (Zuo et al., 2026). In RL, the baseline is the original direct-action actor of SuperMimic, and ODE policy keeps its network and only reads its output as the velocity of the action. We also compare with PPO (Schulman et al., 2017), which learns without a world model.

Implementation. ODE policy uses a FiLM-MLP vector field (Perez et al., 2018) (architectures compared in Appendix B.8), chunks of H=8 steps integrated with RK4, the contractive perturbation, and the diversity head with K=12 components, whose component means are used on LIBERO. The real-robot tasks use the same H=8 and RK4, except on the humanoid. On LIBERO, the binary gripper command is predicted by a separate classification head, a two-layer MLP of 0.27M parameters on the condition, and integrating it with the field instead is ablated in Section 9.3.

In \pi_{0.5}, it replaces the action expert of 430M parameters by a learned query that reads the condition from the VLM once per chunk, a FiLM-MLP field, and a gripper head, 13.7M parameters in total and randomly initialized, and integrates H=8 steps with RK4 (Appendix B.4). In ImageWAM, it reads the condition once per chunk and integrates H=12 steps with Euler (Appendix B.5). In GR00T N1.7, a vector field of about 5M parameters, fine-tuned on top of the model, likewise reads the condition once per chunk and integrates H=16 steps with Euler (Appendix A).

In RL, it takes one Euler step per control step (Eq. (11)), with bounds on the change and on the action. The encoder, the training schedule, and the settings of each baseline are given in Appendix A.

Evaluation. On LIBERO, each visuomotor checkpoint is evaluated with 20 episodes per task from the fixed initial states of the benchmark, the same for all methods, and we report the success rate averaged over the four suites. Execution quality is measured on the successful episodes (Appendix A). Each visuomotor experiment is repeated with three random seeds, and we report the mean and standard deviation over seeds. On the real robots, each method is trained for 300 epochs (50 on the single-arm robot to test the early performance and 90 on the humanoid) and evaluated with 20 trials. In RL, each actor is trained with three random seeds for 3 hours on one GPU and evaluated on all 40 clips following SuperMimic.

We first test whether ODE policy learns faster, as a visuomotor policy, as the action head of large pretrained models, and as the actor in RL.

Training efficiency. Against the six visuomotor baselines on LIBERO, ODE policy learns from the first epoch (Fig. 4(A)). After one epoch, it succeeds in 79.2% of the episodes, nearly twice the best baseline, while diffusion and flow policies have barely started. It passes 85% at epoch 2, an order of magnitude earlier than flow and diffusion policies, and still leads at epoch 100. Integrating over the physical time of the robot is thus far easier to learn, without trading off the final performance.

Data efficiency. With 5 to 50 demonstrations per task (Fig. 4(B)), ODE policy leads FM-DiT at every data scale from epoch 10 on, and the gap grows as data shrink. With 20 demonstrations per task, it reaches 87.7% at epoch 100, above FM-DiT trained on all 50 (85.4%). It matches FM-DiT with less than half of the demonstrations.

Parameter efficiency. Scaling the parameters outside the encoder from 1.5M to 48M (Fig. 4(C)) barely changes the gain. The smallest ODE policy (1.5M) reaches 92.5% at epoch 10, above the largest FM-DiT (48M) at any epoch (at most 87.5%). The advantage comes from the ODE formulation, not from the model capacity.

To test whether the gain carries over to large pretrained models, we replace the action expert of \pi_{0.5} (Physical Intelligence et al., 2025) by a randomly initialized ODE head with about 3% of its parameters (Fig. 5(A)). Without any pretrained action weights, it leads both FM experts early in training, with 96.0% after one epoch against 75.5% for the randomly initialized one, and the pretrained expert catches up only from the second epoch on.

In ImageWAM, which has 4.5B trainable parameters (Fig. 5(B)), the ODE head succeeds in 82.6% after one epoch, against 24.6% for the original head, with A2A (Zuo et al., 2026) in between, and all three converge from epoch 6 on. ODE policy thus keeps its learning efficiency in large pretrained models, where the action head is only a small part of the network.

We finally replace the actor of SuperMimic and keep its world model, critic, rewards, and hyperparameters (Fig. 6), and train PPO for the same time as a reference without a world model. The ODE actor pulls ahead early. Its training return is 37% higher after 0.75 hours (0.630\pm0.007 against 0.460\pm0.008), and its return on all 40 clips is 30% higher after 0.4 hours and stays ahead until the end (0.885\pm0.007 against 0.845\pm0.009), while PPO reaches only 0.452\pm0.021 after 3 hours (comparison with PPO in Fig. S4).

This likely stems from the gradient path along the chain of actions (Section 4.5). The gradient norm with respect to the first imagined action, relative to the last one, is about 0.57 for the direct-action actor and 1.0 to 1.1 for the ODE actor, so early actions receive a stronger learning signal. ODE policy further speeds up an already efficient RL method without any change to its algorithm.

We next examine how fast ODE policy generates actions and how smoothly the robot executes them.

Inference cost. Since the solver barely changes the success rate (Fig. 16(C)), we compare with ODE policy using Euler (Fig. 7(A)). It generates a chunk of 8 actions in 5.7 ms, as fast as A2A-DiT, 10.8 times faster than FM-DiT, and about 100 times faster than DDPM, which exceeds the budget of a 20 Hz controller. Only ACT is slightly faster, at a much lower success rate. Even with RK4, it stays several times faster than FM-DiT, and the ranking holds on an idle GPU (Table S1). ODE policy thus combines the speed of single-pass policies with a higher success rate than generative ones.

Inference cost at scale. In \pi_{0.5}, the ODE head reads the condition once per chunk and runs about 14 times faster than the FM expert with 10 denoising steps, which also saves about a third of the time of the full model (Fig. 8(A)). Its commands also change about half as much at chunk boundaries (Fig. 8(B)). In ImageWAM, the action transformer runs once per chunk and a small vector field carries out the integration, whereas the original head runs the transformer at each of its 10 denoising steps. This cuts the time per chunk about fourfold, as fast as A2A (Fig. 8(C)). Moreover, each action of ODE policy can be sent to the controller as soon as it is integrated (Section 4.3), whereas the baselines must first generate the whole chunk.

Action smoothness. Over the successful episodes, ODE policy has the lowest end-effector jerk at every checkpoint and finishes tasks in fewer control steps than all baselines (Fig. 7(B, C)). In RL, the actions of the ODE actor accelerate 21% less than those of the direct-action actor and less than half as much as PPO after 3 hours (Fig. 6(C)). Since integration links consecutive actions and seamless chunking links the chunks (Section 8), the executed motion is both smoother and more efficient.

We then test how well ODE policy generalizes to perturbations unseen in training, as a visuomotor policy and within a VLA and a WAM.

Evaluated zero-shot on LIBERO-plus with 50 perturbed instances per type and suite (Fig. 9(A)), ODE policy leads clearly after one epoch (30.1% vs. 22.6% for ACT) and later stays on par with the strongest baselines. Per perturbation type (Fig. S1), it leads most under sensor noise, FM-DiT and DDPM-DiT handle a changed initial robot pose better, and a changed camera defeats all methods.

Large pretrained models generalize far better than the visuomotor policies (Fig. 9(B, C)). In \pi_{0.5}, the ODE head, with about 3% of the parameters and no pretrained action weights, leads the randomly initialized FM expert throughout training. In ImageWAM, ODE policy leads throughout training, most clearly early on (70.5% vs. 17.1% for the original head after one epoch). ODE policy reaches its robustness much earlier in training, and on a real robot it also transfers dexterous skills from public data of another lab (Section 7.3).

Since a single vector field may average distinct behaviors, we test whether ODE policy keeps the modes of the demonstrations on a 2D navigation task, where an agent passes one of four gaps in a wall to reach a goal (50 demonstrations per route) and a policy that averages the routes hits the wall. We report the success rate and the mode balance \gamma=4\min_r p_r\in[0,1], where p_r\in[0,1] is the share of successful rollouts through gap r\in\{1,\dots,4\} (Fig. 10). Randomizing the direction of the field at the start of a chunk suffices to send the integrated path into another mode, without a multi-step generative sampling process.

With the diversity head, ODE policy takes all four routes from the first epoch (Fig. S2). Over the first five epochs, it is more balanced than FM-DiT, with 3.9 times its \gamma after one epoch, when it also succeeds more often. FM-DiT is more balanced at epoch 10, and at epoch 20 both are similarly balanced and almost always succeed. A2A-DiT with initial noise perturbation (Zuo et al., 2026) learns only the two inner routes (\gamma=0), and MARS covers all routes but learns slowly. ODE policy keeps diverse behavior while learning fast, also on a real bimanual task (Section 7.2).

We then deploy ODE policy on four real robots to test whether its advantages carry over to high-precision, long-horizon, deformable, multi-modal, dexterous, and loco-manipulation tasks, and finally compare the inference cost and the smoothness across the robots.

On a Franka Research 3 arm, all policies are trained on 40 demonstrations per task for only 50 epochs, to test their performance early in training. ODE policy achieves the highest success rate on all four tasks (Fig. 11), with the clearest margins in folding a sock and inserting a block (15 and 14 of 20 trials against 8 and 4 for the best baseline). A2A-DiT comes closest on the first two tasks, likely because it also generates each chunk from the previous actions, but fails all insertions.

At the chunk boundaries, ODE policy also commands the lowest acceleration on every task, 3.6, 1.1, 2.5, and 2.2 rad/s^2, against 2.8 to 9.1 for A2A-DiT and 8.3 to 26.0 for the diffusion and flow matching baselines. It learns multi-stage, deformable, and high-precision tasks reliably from a few dozen demonstrations within a short training.

On the Galaxea R1 Lite, ODE policy is tested on four tasks, two of them with both arms (Fig. 12).High-precision and long-horizon tasks. In flower insertion, the thin stem must meet the narrow opening of a vase, and the long stem of the poppy amplifies small errors at the gripper. ODE policy succeeds more often than FM-DiT with both flowers (60% vs. 40% with the dahlia), likely because its motion stays smooth up to the opening. In the microwave task, learned from only 34 demonstrations, it succeeds in 75% of the trials against 20% for FM-DiT, which leaves the door open in 9 of its 16 failures, against 2 of 5 for ODE policy.

Chaining two insertions into the same vase, it inserts the first flower far more often than FM-DiT (55% vs. 20%), although the second insertion, into a vase that already holds a stem, is hard for all methods. Both diffusion policies fail almost every trial of the three tasks. ODE policy thus keeps the error of each step small enough for precise and long sequences with both arms.

Multi-modal task. In the drawer task (Fig. 12(D)), one arm puts an apple into an open drawer and the other closes it, and the demonstrations assign the two roles both ways equally often. With the diversity head (Section 4.4), ODE policy takes both modes, with the left arm placing the apple in 8 of the 20 trials and the right arm in 12, and succeeds in 5 of 8 and 7 of 12, 60% in total. FM-DiT also goes for the apple with both arms but never places it. The multi-modality seen in navigation carries over to a bimanual robot.

Pick-and-place with a dexterous hand. On a Sharpa North robot with a Sharpa dexterous hand, whose joints greatly enlarge the action space, ODE policy picks up a can and places it on a plate in 18 of 20 trials after training on 50 demonstrations, against 14 for FM-DiT and 8 for DDIM-UNet (Fig. 13(A)).

Cross-setup transfer. We next train on 50 demonstrations per task from the public SharpaDex dataset (Sharpa Robotics, 2026), recorded by Sharpa in its own lab with the same robot and hand, and deploy the policies in our lab without any demonstration from our setup (Fig. 13(B-D)). In reorienting a fallen cup upright, with other cups and another background, ODE policy succeeds in 17 of 20 trials, while FM-DiT never grasps the cup and DDIM-UNet hovers above it with the hand jittering at the period of one chunk.

In pouring pills between two cups with two hands, using cups of other colors, it succeeds in 17 trials against 10 for FM-DiT and none for DDIM-UNet. In stacking a red cube on a green one, whereas the demonstrations use wooden cubes, it succeeds in 13 of 20 trials, while both baselines always fail. ODE policy thus carries skills across setups, consistent with its robustness to unseen perturbations in simulation (Section 6.3).

We finally test whether ODE policy also drives the whole body of a humanoid. On a Unitree G1 with Inspire DFX dexterous hands, it replaces the action head of GR00T N1.7 (Bjorck et al., 2025) (Fig. 14). Both tasks are long-horizon and couple walking with a precise grasp. In the toy task, the robot walks to a toy on the floor, squats to grasp it, stands up, and places it into a box on the sofa, so the legs, the torso, and the arms must move together. In the microwave task, it grasps a small rice ball from a table, turns and walks to a microwave, puts the rice ball inside, and closes the door.

Trained on 90 demonstrations per task for 90 epochs, ODE policy succeeds in 60% and 70% of 20 trials, against 35% and 30% for the original head of GR00T. The vector field thus also carries whole-body loco-manipulation, where small errors of the stance and the grasp likely accumulate over the long task.

On one task of each of the first three robots, the close-box, microwave, and can tasks (Fig. 15), ODE policy generates a chunk 3.5 to 27 times faster than the diffusion and flow matching baselines, even with RK4. Since each chunk continues from the end of the previous one, its command acceleration at chunk boundaries stays at or below that of the demonstrations on the dual-arm robot and the hand and close to it on the single-arm robot, whereas the baselines reach several times that of the demonstrations.

The measured jerk of its arm and hand joints also matches or undercuts the demonstrations, while the arm jerk of the baselines exceeds them by up to an order of magnitude. A2A-DiT, which also starts from the previous actions, moves about as smoothly on the single-arm robot (39 rad/s^3) and generates a chunk faster (8.6 ms), but accelerates more at chunk boundaries (9.1 against 3.6 rad/s^2). Appendix B.6 reports the same measures on the cup and pill tasks.

We ablate the design choices of ODE policy one at a time with all other settings fixed, namely the chunk length and the solver (Fig. 16), the contractive perturbation, seamless chunking, and the placement of the proprioception (Fig. 17), and the number of components of the diversity head (Fig. 18). The diversity head at inference and the architecture of the vector field are ablated in Appendix B.8.

Chunk length. With chunk length H=1 in training and execution (Fig. 16(A, B)), the policy reaches only 76.4% at epoch 100 and is the slowest per action, since the encoder runs at every step. From H=4 on, the success rate stays above 91% (best at the default H=8), while the time per action keeps falling, although training shows occasional loss spikes for H\ge12. Consistent with the finding that chunking mitigates the compounding errors of behavioral cloning (Lazzati et al., 2026; Park, 2026), chunking is essential, and H=8 balances success rate and inference time.

Integration solver. Replacing RK4 with RK2 or Euler changes the success rate at epoch 100 by less than one point, within the variation across seeds, and all three stay above FM-DiT and A2A-DiT throughout training (Fig. 16(C)). The cheaper solvers shorten both training and inference (Fig. 16(D)). With Euler, training takes about as long as for FM-DiT and less than for A2A-DiT, so the gain does not come from a longer training. Since even Euler applies the same vector field at every step, the performance comes from the ODE formulation, not from an accurate solver.

Contractive perturbation. Without the contractive perturbation (Fig. 17(A)), the success rate after one epoch drops from 79.8% to 58.4% (with 10 episodes per task, hence 79.8% instead of 79.2% for the default), and the gap closes by epoch 20. Early in training, the inaccurate field lets seamless chunking drift away from the demonstrations, and the perturbation teaches it to return. A larger magnitude learns faster, but twice the default later stays slightly lower, likely because large offsets pull the field away from the fine motion of the demonstrations. Even without the perturbation, ODE policy is still well ahead of FM-DiT and A2A-DiT after one epoch.

Seamless chunking. Restarting each chunk from the measured state instead (Fig. 17(B, C)) discards the lead of the desired action over the measured state and lowers the success rate after one epoch from 79.8% to 47.8%. After training, the success rates are close, but the restarted policy jumps at every chunk boundary, with a 3 to 4 times higher boundary ratio, a 1.3 to 2.2 times higher jerk, and 8% to 19% longer episodes. Seamless chunking is thus key to both fast learning and smooth execution.

Proprioception. Feeding the proprioception to the vector field only, to both the condition and the field, or to the condition only performs similarly from epoch 5 on (Fig. 17(D)). After one epoch, the field-only variant is the highest, while the condition-only variant varies strongly across seeds. Feeding it to the field performs at least as well as the conventional placement and makes early learning more reliable.

Number of components. The number of components K only bounds how many modes the diversity head can represent (Fig. 18). At K=4, the head cannot reliably separate the four routes of the navigation task, and \gamma varies strongly across seeds. From K=8 on, it uses about five groups of components at the start, close to the four routes, and about one group per state on uni-modal LIBERO. A smaller K is slightly better after one epoch, likely because the untrained head offsets the actions less, and at epoch 20 the success rate barely changes. K only needs to exceed the number of modes, and we use K=12 throughout.

We presented ODE policy, which models how the action of a robot evolves over its physical time as an ODE, so that each action is integrated from the previous one. In IL, it learns the vector field by integrating over short action chunks, seamless chunking joins successive chunks without jumps, and the contractive perturbation keeps the policy close to the demonstrations. On LIBERO, ODE policy reaches 79.2% after one epoch and 93.8% at epoch 100, matches FM-DiT with less than half of the demonstrations, and generates a chunk of 8 actions in 5.7 ms.

As the action head of the \pi_{0.5} VLA, it reaches 96.0% after one epoch against 75.5% for its flow matching expert with about 3% of its parameters, and as the action head of the WAM ImageWAM, 82.6% against 24.6% for the original head, generating a chunk 4.1 times faster. On 14 real-world tasks across single-arm, dual-arm, dexterous, and humanoid robots, it achieves the highest success rate on every task, and its motion is smoother than the human demonstrations in most cases. As the actor of SuperMimic, it reaches a higher return early in training and still 0.885 against 0.845 at the end of training.

These results suggest that building the continuity of physical motion into the policy, rather than learning it from data, makes robot policies more efficient in learning, data, parameters, and execution, and that this gain scales from small visuomotor policies to large pretrained models and carries over from IL to RL. Beyond the results, viewing a policy as a vector field in the physical time of the robot opens uses that direct-action policies do not naturally offer. We share three aspects with preliminary experiments, as starting points rather than finished solutions, and close with a broader view of what the field may represent.

Data collected with handheld interfaces such as UMI (Chi et al., 2024) or from human videos (Kareer et al., 2026) record the measured pose but not the command sent to the controller. A policy can then only learn the measured state, which lags behind its target, so the robot moves slower than in the demonstrations (Zhao et al., 2026). Since ODE policy learns a vector field, the velocity of each action is available at no extra cost. We feed it to the damping term of the PD controller, i.e., k_p(\mathbf{p}_{\text{ref}}-\mathbf{p})+k_d(\dot{\mathbf{p}}_{\text{ref}}-\dot{\mathbf{p}}) instead of k_p(\mathbf{p}_{\text{ref}}-\mathbf{p})-k_d\dot{\mathbf{p}}, where \mathbf{p},\mathbf{p}_{\text{ref}}\in\mathbb{R}^{d_a} are the measured and reference poses and k_p,k_d\in\mathbb{R}_{>0} are the proportional and derivative gains, and train all policies on the measured poses of LIBERO only (Fig. 19(A, B)).

With the velocity, the robot keeps the demonstrated pace. Successful Long episodes take 253 instead of 305 steps, and long tasks that ran out of time are now completed, raising Long from 51% to 72% (FM-DiT: 24%). Faster motion, however, makes precise placement harder, and on Spatial the success rate drops from 90% to 80%. This hints that the velocity could be modulated by the phase of a task, e.g., fast in free space and slow near contact, which is natural to express with a vector field but hard with direct-action policies.

Since ODE policy is a vector field in continuous time, the integration step is a choice made at deployment rather than a part of the model. We take the model trained with one RK4 step per control step at 20 Hz and change only the integration at deployment (Fig. 19(C)). Integrating each control step with 2 or 4 substeps moves the integrated path by at most 1 mm, against about 10 mm between consecutive actions, and the success rate changes from 94.8% to 92.8%. Reducing the step to 1/2 or 1/4 and sending every intermediate point runs the same model at 40 or 80 Hz, with 16 or 32 actions per chunk, at 93.3% and 92.5% success and the same completion time.

In contrast, a conventional policy outputs actions at the fixed step of its training data and must interpolate them to run at a higher rate, and even policies conditioned on physical time keep a fixed action rate (Wang et al., 2026). One model could therefore serve low-level controllers of different frequencies without retraining, and the integration step might even be adapted online, e.g., refined near contact where precise control matters most.

An ODE describes signals that change continuously. Contact tasks nevertheless do not hurt ODE policy, e.g., 96.2% vs. 78.8% for FM-DiT at epoch 10 on eight contact-rich LIBERO tasks. The gripper command, in contrast, is binary on some robots, e.g., in LIBERO, while it is continuous on our real robots. The LIBERO experiments above predict the binary command with a separate classification head. This simple head is effective and leaves the smooth motion of the arm to the field.

To probe the ODE itself, we instead integrate the gripper as one more state of the field and send its sign, with each chunk starting the gripper state at the last command. Without any further design, the success rate drops from 79.2%, 95.0%, and 92.8% to 74.5%, 91.8%, and 92.2% at epochs 1, 5, and 10, mostly on Long, which requires repeated grasping and releasing. Even so, it still exceeds all baselines after one epoch (74.5% vs. at most 43.2%) and at epoch 10 (92.2% vs. at most 86.9%). Neural ODEs built for discontinuous dynamics, such as learned event functions (Chen et al., 2021a) and jump terms (Jia and Benson, 2019), might further empower ODE policy.

Actions learned without demonstrations need not be continuous either. In our early experiments with model-free RL, the learned actions often jumped between control steps, while the compliant PD controller still kept the motion smooth. There, ODE policy brought little gain and sometimes even hurt, likely because its continuity also smooths the exploration. Such jumps are, however, usually treated as a flaw rather than a need, since they load the motors and widen the gap between simulation and reality, and RL for robots commonly penalizes the change of actions (Mysore et al., 2021; Rudin et al., 2022). ODE policy thus suits best where the commands themselves should be smooth, e.g., when imitating demonstrations or deploying on hardware.

In physics, differential equations describe how a state changes. The action of a robot is different. It is a command, an intention of where to go next, so it is not obvious that it should follow such a law. Neuroscience suggests that it may. When a monkey reaches, its motor cortex does not simply encode the target. Its activity evolves like a dynamical system from a preparatory state, and the movement unfolds from it (Churchland et al., 2012; Shenoy et al., 2013). Human reaching is also smooth, close to minimum jerk (Flash and Hogan, 1985).

ODE policy works in a similar way. At the start of each chunk, it makes a discrete choice, e.g., which arm places the apple, and the vector field then unfolds the motion. A policy might thus only need to decide at a few key points of a task, e.g., where its modes branch, and leave the rest to the learned dynamics.

We thank Sharpa Robotics for releasing the SharpaDex dataset (Sharpa Robotics, 2026), whose demonstrations we use for the cup reorientation, pill pouring, and cube stacking tasks, and for their support with the Sharpa North robot and the Sharpa hand.

Simulated benchmarks. LIBERO has four suites (Object, Spatial, Goal, and Long) with 10 tasks each and 50 demonstrations per task. One model is trained on all 40 tasks and evaluated on each suite separately. LIBERO-plus perturbs the camera, the initial robot pose, the object layout, the background, the lighting, and the sensor noise. \pi_{0.5} and ImageWAM are tested on LIBERO and on a shared set of 2008 LIBERO-plus instances, which also perturb the language instruction.

Single-arm robot tasks. All four tasks on the Franka Research 3 arm use multiple cameras, and the actions are joint angles. In the box task, the arm puts a mango into a box and then closes the lid. Its 40 demonstrations are collected with a SpaceMouse through the HIL-SERL teleoperation framework (Luo et al., 2025). In the key task, the arm grasps a key and hangs it on a hook of a wooden key holder, learned from 40 demonstrations collected in the same way. In the sock task, the arm takes a sock from the top of a small cabinet, folds it on the table, puts it into the open drawer, and closes the drawer, learned from 40 demonstrations. In the insertion task, the arm grasps a blue block and inserts it into a matching hole of a black board, learned from 40 demonstrations. Inference times on this robot are measured on one RTX 5080.

Dual-arm robot tasks. All tasks on the dual-arm and dexterous-hand robots use joint angles as actions at 15 Hz. In the flower insertion task, one arm of the Galaxea R1 Lite grasps a long-stemmed poppy or a short-stemmed dahlia from a glass vase and inserts its thin stem into the narrow opening of another vase, so a small error of the gripper pose makes the stem miss the opening. One model is trained on both flowers from 95 demonstrations (38 poppy and 57 dahlia), with a head and a wrist camera. In the microwave task, one arm grasps a bowl of corn, places it in the microwave, and pushes it in, and the other arm then closes the door. It is learned from 34 demonstrations, with a head and two wrist cameras.

In the two-flower task, one arm inserts two flowers one after the other into the same vase, learned from 95 demonstrations. In the drawer task, one arm puts an apple from the top of a cabinet into its open drawer, and the other arm closes the drawer. The demonstrations contain both assignments of the arms, 25 with the left arm and 25 with the right arm placing the apple, with a head and two wrist cameras.

Dexterous-hand tasks. The policy runs at 15 Hz, and each predicted chunk is linearly interpolated to 60 Hz joint position targets for the arm and the 22 joints of each hand. In the can task, the Sharpa North robot picks up a can with its Sharpa hand and places it on a plate, learned from 50 demonstrations. In the cup task, the hand picks up a fallen cup, reorients it, and places it upright. Its 50 demonstrations are drawn at random from the reorient_cup_upright task of the public SharpaDex dataset (Sharpa Robotics, 2026), recorded by Sharpa in another lab, and the policies are tested in our lab with other cups and another background.

In the pill task, the two hands pour pills from one cup into another and put both cups back. Its 50 demonstrations are those of one recording session of the transfer_pills_between_cups task of SharpaDex closest to our placement of the cups, and the policies are tested with cups of other colors. In the stacking task, the hand stacks a red cube on a green cube. Its 50 demonstrations come from the stack_cube task of SharpaDex, and the policies are tested in our lab with colored cubes instead of the wooden cubes of the demonstrations.

Humanoid tasks. The Unitree G1 humanoid with two Inspire DFX dexterous hands is controlled through GR00T N1.7 (Bjorck et al., 2025). As in ImageWAM, ODE policy reads the condition from GR00T once per chunk. A vector field of about 5M parameters, fine-tuned on top of GR00T, integrates chunks of H=16 steps with Euler, with the diversity head as in all IL experiments. The baseline is the original action head of GR00T N1.7.

Visuomotor policies. All methods share the same observation encoder, a ResNet-18 (He et al., 2016) with group normalization (Wu and He, 2018) and random cropping that encodes the last 8 image frames, and a CLIP text embedding (Radford et al., 2021) of the instruction. Except in the model-size study, the parameters outside the encoder are matched to about 24M (ODE-MLP 24.40M, ODE-DiT 24.15M, FM-DiT 23.93M, and the others within 5%). All methods are trained with AdamW (Loshchilov and Hutter, 2019), learning rate 10^{-4}, batch size 32, and a cosine schedule defined over 100 epochs, and shorter runs stop early under the same schedule.

The model-size study changes the width of the action head, with 4 layers for both methods. For the 1.5M ODE policy, the network that maps the observation features to the condition is also narrowed (condition width 136 instead of 512), since it alone has 4.2M parameters at the default width. Each visuomotor experiment is run with three random seeds, except ODE-DiT with one seed. The data-efficiency study changes only the number of demonstrations per task, so fewer demonstrations also mean fewer gradient steps per epoch.

ODE policy. The vector field is a 4-layer FiLM-MLP of width 1732 that takes the action state and the proprioception as input and is modulated by the condition. It corresponds to the conditional residual block of the 1D UNet of FM-UNet and DDPM-UNet without the temporal convolution, since the field takes a single state rather than a sequence of actions, and we therefore call it ODE-MLP in the tables. ODE-DiT replaces it with AdaLN Transformer blocks of width 512 and 4 layers (Appendix B.8).

The state is the desired action of the LIBERO operational space controller, i.e., the current pose plus 0.05 m and 0.5 rad times the normalized command, so that a unit tracking gain reproduces the demonstrated command exactly. Each chunk of 8 steps is integrated with RK4 at 20 Hz. Half of the training segments are perturbed by about 1 cm and 0.03 rad with \rho=0.7. The diversity head has K=12 components. LIBERO uses the component means and the navigation task samples them. The binary gripper is predicted by a separate head.

Baselines. FM-DiT, FM-UNet, DDPM-DiT, and DDPM-UNet predict chunks of 8 actions with the DiT or the 1D UNet head of the corresponding generative model. A2A-DiT starts its flow from the history of actions, perturbed by Gaussian noise of standard deviation 0.5. ACT uses its CVAE Transformer decoder. FM-DiT and FM-UNet integrate their flow with 10 midpoint steps, i.e., 20 network calls per chunk, DDPM-DiT and DDPM-UNet denoise in 100 steps, and A2A-DiT generates a chunk in one flow step. As for ODE policy, every baseline reads the last 8 image frames, predicts a chunk of 8 actions, and executes all of them before the next observation.

Evaluation and metrics. Each LIBERO checkpoint runs 20 episodes for each of the 10 tasks of each suite from the fixed initial states of the benchmark. Execution quality is measured on the successful episodes. The jerk is the RMS jerk of the measured end-effector position. The in-chunk and cross-chunk smoothness are the mean change of the command between consecutive steps inside a chunk and at the first step of a new chunk, and their quotient is the boundary ratio. The completion time is the number of control steps. Inference times in the main text are measured during these evaluations on shared GPUs, and times on one idle RTX 4090 are reported in Table S1. LIBERO-plus samples 50 instances per perturbation type and suite with the same sampling seed for all methods.

Table S1 repeats the timing of Fig. 7(A) on one idle RTX 4090, and the ranking stays the same. With RK4, ODE policy takes 8.82 ms per call, 4.8 times less than FM-DiT and 38 times less than DDPM-UNet, and only the single-pass ACT and A2A-DiT are faster. With Euler, it takes 4.25 ms, close to these single-pass policies. The encoder takes about 1.2 ms for every method, so the differences come from the action head. Longer chunks spread one call over more actions, and the time per action falls from 3.53 ms at H=1 to 1.09 ms at H=16.

Fig. S1 breaks the zero-shot success of the visuomotor policies on LIBERO-plus down by perturbation type at epoch 100, as summarized in Section 6.3.

Fig. S2 shows the rollouts behind Fig. 10 for one seed. After one epoch, ODE policy already passes through all four gaps with few failures, whereas FM-DiT fails in many rollouts and mostly takes the inner routes. A2A-DiT collapses to the two inner routes throughout training. MARS covers all four routes, but many of its rollouts still fail at epoch 10.

We fine-tune \pi_{0.5} (Physical Intelligence et al., 2025) on the four LIBERO suites jointly (1693 demonstrations) for three epochs with one seed. All parameters are trained, including the VLM of 2.92B parameters, with AdamW, a peak learning rate of 5\times10^{-5}, and a global batch size of 384 on eight A100 GPUs. Each method uses the current images of an external and a wrist camera at 224\times224 and predicts and executes chunks of 8 actions.

ODE policy replaces the action expert of \pi_{0.5} (430M parameters with its projections) by a learned query that reads the image and language features of the VLM once per chunk, a FiLM-MLP vector field of four residual layers of width 512, and a gripper head, 13.7M parameters in total, all randomly initialized. As in all IL experiments, it also uses the diversity head. The proprioception enters only the field and the gripper head. The field integrates each chunk with RK4 from the end of the previous one, with the contractive perturbation (1 cm and 0.03 rad, applied to half of the training chunks). FM integrates its flow with 10 Euler steps.

The VLM is pretrained in all methods, and the suffix -R only marks a randomly initialized action expert. Each LIBERO checkpoint is evaluated on the 10 fixed initial states of each task, and LIBERO-plus on the shared set of 2008 instances with one episode each. The parameters of ODE policy outside the VLM are about 3% of those of the experts, so the comparison is not at matched capacity.

Table S2 lists the success rate per suite at epoch 1. The early lead of ODE policy over the pretrained FM expert holds in all four suites and is largest on Long (92.0% vs. 81.0%). Successful episodes of ODE policy and of the pretrained FM expert take a similar number of control steps (156.7 and 156.1).

We fine-tune ImageWAM (Zhang et al., 2026) on the four LIBERO suites jointly (1712 demonstrations) for 10 epochs with one seed. Its image transformer (3.9B parameters) and action transformer are fine-tuned, and the text encoder is frozen. ODE policy keeps the 25 blocks of the action transformer, which read a 512-dimensional condition once per chunk through a learned query, and replaces its input, time embedding, and output layers with a FiLM-MLP vector field of four residual layers of width 512. The proprioception enters only the field.

The field integrates chunks of 12 steps with Euler, with the contractive perturbation (1 cm and 0.03 rad, applied to half of the training chunks), seamless chunking, and the diversity head, and a separate head predicts the gripper. The settings that differ between the heads are listed in Table S3. LIBERO-plus uses a shared set of 2008 instances with one episode each and the same seed for all methods, and its success rate is weighted by perturbation type. All standard deviations in this subsection are over tasks, not over seeds.

Fig. S3 shows each suite. The early lead of ODE policy is largest on Spatial and Long on LIBERO, and it lasts until epoch 10 on LIBERO-plus Spatial. Table S4 lists the success rate per perturbation type. On the full LIBERO-plus set of 10030 instances, ODE policy at epoch 10 succeeds in 88.7% of the episodes, close to its 89.9% on the shared set. The baselines were not evaluated on the full set.

We report inference cost and smoothness on the cup task of the dexterous hand in Table S5. The baselines never succeed on this task, so their measures come from failed trials and serve only as a reference. ODE policy generates a chunk 3.4 and 5.1 times faster than FM-DiT and DDIM-UNet. Its acceleration at chunk boundaries is 0.86 times that inside chunks, close to the 0.96 of the demonstrations, whereas the baselines reach 2.03 and 2.97. Its arm jerk is about one third of that of the baselines and below that of the demonstrations, as on the can task.

The pill task in Table S6 gives the same picture with a baseline that also succeeds. ODE policy generates a chunk 3.5 times faster than FM-DiT. Its ratio of the acceleration at chunk boundaries to that inside chunks is 1.45, close to the 1.24 of the demonstrations, against 2.17 for FM-DiT. Its arm jerk is half of that of FM-DiT and below that of the demonstrations, while the hand jerk of both methods is close and below that of the demonstrations.

We build on an open-source reproduction of SuperMimic (Liao et al., 2026a). Each iteration steps 4096 simulated environments once and stores the transitions, trains the world model on them, and updates the actor by backpropagating the discounted return over 32 steps imagined in the frozen world model, plus the value of the critic at the last step. The task is whole-body tracking of the 40 complete LAFAN1 clips (2.45 hours at 50 Hz, 100 to 300 s each) with a Unitree G1 humanoid with 29 actuated joints. The action is the offset of the joint-position targets from the default pose, tracked by a PD controller.

The actor encodes the target motion into a latent \mathbf{z}_t\in\mathbb{R}^{32} and decodes it with 10 frames of proprioception into the action, with 8.91M parameters. We add the anchor-relative pose of BeyondMimic (Liao et al., 2026b) to the goal for both actors, since with proprioception alone the heading drifts over such long clips and the return saturates at about 0.58.

The ODE actor keeps this network and its initialization and only reads the decoder output as the velocity in Eq. (11), where the previous action is the noise-free output of the actor, so exploration noise does not accumulate along the integration. Without bounds, the integration turned an early error of the world model into a drift of the action and a collapse of the return in one of the runs. We therefore bound the change per step by 1.62 and each joint of the action by its own limit. Both bounds are set slightly above the 99th and 99.9th percentiles of the actions of converged policies of both actors, so they are rarely active.

Everything else, including the world model, the critic, the rewards, the training noise, and the hyperparameters, follows the reproduction. Each run trains for 3 hours on one NVIDIA H200 GPU, about 33k iterations. Following SuperMimic, every clip is played once from its first frame with the deterministic policy and without noise or randomization, and an episode ends when the pelvis deviates from the reference beyond a threshold. We report the reward per step normalized by its maximum, averaged over all steps of each clip with the steps after a fall counted as zero and then over the 40 clips, and the mean squared second difference of the executed actions.

PPO (Schulman et al., 2017) uses the same environment, observations, rewards, termination conditions, domain randomization, and clips as SuperMimic, but no world model. It samples its own exploration actions, so the execution noise of the environment is turned off. Its hyperparameters follow the G1 tracking configuration of BeyondMimic (Liao et al., 2026b), with 8192 parallel environments and the network size of SuperMimic. Each run also trains for 3 hours on one H200 GPU. Since an iteration of PPO differs from one of SuperMimic, all curves are plotted over wall-clock time. Fig. S4 compares the returns of the ODE actor and PPO. The training return of PPO includes its own exploration noise and is shown only for reference.

Diversity head. The head reads the features of the field with the gradient stopped, and its loss does not reach the field, so the field receives exactly the same gradient with or without the head (Section 4.4). The head thus leaves learning unchanged and only alters the actions at inference. We evaluate the same models of three seeds without the offset (\boldsymbol{\epsilon}=\mathbf{0}, i.e., the plain ODE), with the mean of the drawn component, and with full sampling within the component (Table S8).

After one epoch, when the head is not yet trained, the offset lowers the success rate from 85.3\pm1.9% to 79.8\pm1.6% with component means and to 52.1\pm0.1% with full sampling. From epoch 5 on, the three differ by at most 4.2 points, and full sampling even reaches the highest 94.8\pm0.4% at epoch 20. The diversity head therefore mainly affects the early performance, which component means largely preserve, and we use component means for uni-modal tasks.

Vector field architecture. We replace the FiLM-MLP vector field with AdaLN Transformer blocks of FM-DiT, keeping the number of parameters (ODE-DiT, Table S7). With the Transformer, ODE policy still outperforms all baselines, with 77.2% after one epoch and 91.2% at epoch 100 (one seed), against at most 43.2% and 87.8%, and it exceeds FM-DiT with the same blocks by 5.8 points at epoch 100. However, it stays below the MLP field at every checkpoint and is much slower, training at 3.5 instead of 17.1 iterations per second and taking 51.9 instead of 11.0 ms per chunk (Table S9).

Two reasons explain this. First, RK4 evaluates the field 32 times per chunk, in training as well as in execution, so the overhead of each Transformer call is multiplied. Second, the Transformer of FM-DiT models the dependencies among the actions of a chunk, whereas in ODE policy the integration already produces the chunk step by step, and the field only maps the current state to its velocity, a low-dimensional mapping that an MLP fits well. A simple MLP field is therefore sufficient, as the integration carries the temporal structure of the chunk.