Flow matching

Overview

Flow matching trains a network to predict a velocity: the direction and speed that move a noisy sample towards a data sample. Training picks a random time, mixes noise with the data at that time, and regresses the velocity between the two. Sampling starts from noise and follows the learned velocity with a numerical ODE solver, often with only a few Euler steps 2512.05964 §4 2603.10448 §4.1 2603.10448 alg. 2 2503.14734 §2.1.

Most variants share the regression target. It is the difference between the data and the noise, the same for every time, and the model is conditioned on the time 2512.05964 alg. 1 2603.10448 eq. 2–3 2511.19433 §3.1 2601.10471 alg. 1. The exceptions are the two language variants. They keep a continuous path but train with token cross-entropy. LangFlow derives that loss as a flow-matching objective under a Bregman divergence 2604.11748 §3.1. S-FLM moves its latents over a sphere rather than a line, and its velocity is a sum over the vocabulary 2605.11125 eq. 15.

The papers below use flow matching in four settings. Five use it as a robot action head, and the core loss is the same in all five; they differ in what they add around it. One uses it as a navigation trajectory head. One uses it as a frozen behaviour prior for offline reinforcement learning. Two use continuous-path models over token embeddings for language. The language variants report 128 to 1024 sampling steps 2604.11748 app. NFE table 2605.11125 tab. 2, against four steps for GR00T N1 2503.14734 §2.1.

Variants

Standard flow action head in a VLA

GR00T N1 pairs a vision-language model with a diffusion transformer (DiT) that outputs 16-action chunks, and trains the DiT with the flow-matching loss 2503.14734 §2.1. Flow time is drawn from a Beta distribution rescaled by 0.999, and sampling takes four Euler steps from noise [arxiv:2503.14734 §2.1]. The head reads features from layer 12 of the language model rather than the final layer, because the authors found the middle layer faster and more successful 2503.14734 §2.1. The paper reports 63.9 ms to sample a 16-action chunk on an L40 GPU in bf16 2503.14734 §2.1. DiT4DiT reuses this action DiT design 2603.10448 §4.2. Card: GR00T N1: An Open Foundation Model for Generalist Humanoid Robots.

The paper also adds latent-action pretraining on human video and a localisation loss on the VLM tokens, summed with the flow loss [arxiv:2503.14734 §2.2] 2503.14734 app. F. Those parts sit outside the action head, but the paper's results are for the full model, so they do not show how a head trained without them performs. Author-reported: in simulation the model reaches 45.0% average success against 33.4% for Diffusion Policy. That headline average does not follow from its own suite columns, so check the per-task numbers before quoting it 2503.14734 tab. 2 2503.14734 tab. 4. On real GR-1 tasks with 10% of the post-training data it reaches 42.6% against 10.2% for Diffusion Policy [arxiv:2503.14734 tab. 3]. The repository the paper links is a later release (N1.7) with a different backbone and an action horizon of 40, so N1 must be pinned separately 2503.14734 §1 gr00t_n1d7.py.

Flow policy with training-time real-time chunking

A policy that predicts the next chunk of actions with flow matching has to join the new chunk to the chunk still running. Inference-time real-time chunking (RTC) enforces the overlap by guidance at every denoising step, which needs backpropagation at each step 2512.05964 §1 2512.05964 §4. The training-time variant instead simulates an inference delay during training, gives the committed prefix as clean actions with flow timestep 1, and computes the loss only on the postfix. Nothing extra runs at inference, and the sampler has the same interface as the inference-time one 2512.05964 §4 2512.05964 alg. 1. Card: Training-Time Action Conditioning for Efficient Real-Time Chunking.

The method needs a separate flow timestep for each action step, which the paper implements with per-token modulation in an adaLN-zero transformer. It adds no learnable parameters 2512.05964 §4 2512.05964 fig. 2. Author-reported: in simulated Kinetix the variant beats the inference-time one at inference delays of 2 and above, and its advantage grows with the delay 2512.05964 §5.1 2512.05964 fig. 3. On box building and espresso with the pi0.6 model it matches the inference-time success and speed, with lower end-to-end latency (108 ms against 135 ms) 2512.05964 §5.2 2512.05964 fig. 5.

Joint video-action model with flow-matching losses

DiT4DiT couples a video diffusion transformer with an action diffusion transformer. Both are trained with flow-matching losses. The action head reads hidden features from one block of the video model, taken at a fixed noise level, so generating frames is not needed at control time. The video model starts from a pretrained video generator 2603.10448 §4.2 2603.10448 §4.4. Card: DiT4DiT: Jointly Modeling Video Dynamics and Actions for Generalizable Robot Control.

Three timesteps are used: one for the video loss, a feature timestep, and one for the action loss. The action time is drawn from a Beta distribution 2603.10448 §4.3 2603.10448 app. A.1. At inference, one pass of the video backbone produces the features, then four Euler steps integrate the action velocity 2603.10448 app. A.1 2603.10448 alg. 2. Author-reported, trained from scratch: 98.6% average success on LIBERO and 50.8% average over 24 RoboCasa-GR1 tasks, with the highest average among the compared policies on both 2603.10448 tab. 1 2603.10448 tab. 2. The paper's ablations on five RoboCasa tasks found that a single feature denoising step gives the highest success, and that layer 18 is the best extraction layer while layers 24 to 28 collapse 2603.10448 §5.4 2603.10448 fig. 8. The paper says the joint objective trains both models, but the released code detaches the features, so the action loss does not reach the video model 2603.10448 §4.3 Cosmos25.py.

Auxiliary motion-image head on a pi-series VLA

This variant keeps the action head as it is and adds a second flow-matching head. It is a diffusion transformer that predicts the latent of an optical-flow image for the next second, with flow computed by RAFT between frames 2512.18007 §3.2 2512.18007 app. A.1. The two losses are summed without weights, and the motion head is not run at inference, so the action path is unchanged 2512.18007 eq. 7 2512.18007 §1. The paper trains it in two stages: the motion head alone first, with the rest frozen, then all parts together except the frozen VAE 2512.18007 §3.3. Card: Robotic VLA Benefits from Joint Learning with Motion Image Diffusion.

The paper compares the target against two other auxiliary signals on LIBERO with the pi0.5 backbone. The motion image gives 97.5% average success, against 95.7% for a future RGB image and 95.1% for a language description of motion. Action only gives 96.9% 2512.18007 tab. 3. Author-reported: pi0 goes from 94.2% to 94.7% on LIBERO and from 45.1% to 58.0% on RoboTwin easy-mode average 2512.18007 tab. 1 2512.18007 tab. 2. The gains are small on LIBERO and come from one seed per setting, with no intervals reported 2512.18007 §4.2. No official code has been released; the project page lists it as coming soon.

Multi-horizon action head

Mixture of Horizons (MoH) is a plug-in for an action head that predicts action chunks. Instead of one chunk length, the head is trained on several prefixes of the same chunk, for example lengths 3, 6, up to 30 2511.19433 §3.2 2511.19433 §4.1. The prefixes share one observation context, and one batched pass of the action transformer produces every horizon's prediction, with padding and a mask for the lengths beyond each horizon [arxiv:2511.19433 §3.2]. The paper's MoH experiments apply this to flow-matching heads (pi0, pi0.5) and to a one-step regression head 2511.19433 §4.1.

Each horizon is trained with the base policy's own objective, which for flow-matching models is velocity matching 2511.19433 §3.1 2511.19433 §3.2. A per-step softmax gate, taken over the horizons still valid at that step, fuses the horizon predictions. A balance loss stops the gate from putting all its weight on one horizon 2511.19433 §3.2 2511.19433 fig. 3. Card: Mixture of Horizons in Action Chunking.

The paper also describes a dynamic-inference rule. Agreement between the horizon predictions sets how many steps of a chunk to execute before the next replanning call 2511.19433 §3.3 2511.19433 alg. 1. The paper claims 2.5 times the default throughput 2511.19433 §1, but the sweep is only plotted, so the numbers are not in the text 2511.19433 fig. 6. Author-reported: on LIBERO average, pi0 rises from 93.8 to 95.1 and pi0.5 from 97.7 to 99.0 2511.19433 tab. 1. On pi0.5, a single horizon of 30 gives 97.7 and a stride of 3 gives 99.0 2511.19433 tab. 3. Removing the balance loss gives 98.5, and uniform mean fusion gives 98.4 [arxiv:2511.19433 tab. 4]. The real-robot evidence is 10 to 20 rollouts per task on one platform 2511.19433 §5.

Flow trajectory head in a dual-system navigator

DualVLN pairs a slow vision-language planner with a fast flow-matching trajectory head. The planner, a 7B Qwen2.5-VL, outputs a pixel goal or a view adjustment. It also appends four learnable latent tokens, and their last hidden states condition the head 2512.08186 §3.1 2512.08186 §3.2 2512.08186 app. A. The head is a diffusion transformer that outputs 32 waypoints. It is trained with the flow-matching loss, and it runs on an asynchronous schedule, so it reuses a stale planner output with the newest frame 2512.08186 §3.2 2512.08186 eq. 1–3. Card: Ground Slow, Move Fast: A Dual-System Foundation Model for Generalizable Vision-and-Language Navigation.

Training is sequential. The planner is trained first, then frozen while the latent tokens and the head are trained on pixel-goal samples [arxiv:2512.08186 §3.3] 2512.08186 app. A. The paper does not give the noise schedule, the inference step count or how the 32 sampled paths are combined. The released code uses 10 Euler steps and averages the 32 paths before converting them to discrete actions 2512.08186 §5.2 internvla_n1.py vln_utils.py. Author-reported: 64.3% success on R2R-CE val-unseen with RGB only, against 56.9% for StreamVLN 2512.08186 tab. 1. Its System 2 takes 0.7 s per call and System 1 takes 0.03 s for 32 trajectories, measured on one RTX 4090 by the authors 2512.08186 §5.2. The asynchronous design is needed for that behaviour 2512.08186 §3.2.

Residual refinement on a frozen flow prior (offline RL)

DeFlow uses a multi-step flow policy as an offline RL behaviour prior and keeps it fixed for value learning. The executed action is the flow sample, with its gradient stopped, plus a small residual network that reads the state and that sample 2601.10471 §3.2. The flow itself is trained only by flow matching on logged actions, so Q-learning never changes the prior [arxiv:2601.10471 §3.2] 2601.10471 alg. 1. The refinement is posed as maximising Q subject to a budget on the mean squared residual per action coordinate. The paper solves this with an adaptive penalty whose weight rises while the residual is above budget, so no gradient passes through the ODE solver [arxiv:2601.10471 §3.2] 2601.10471 app. B.1. Card: DeFlow: Decoupling Behavior-Prior Modeling and Value Maximization for Offline Policy Extraction.

The budget is a per-task setting. The appendix table gives one value for each task family, and the paper says an action-variance heuristic is only a rough guide to it 2601.10471 app. B.1. The penalty is enforced on minibatches, so the paper gives no hard per-state guarantee 2601.10471 §3.2 2601.10471 app. A. Author-reported on OGBench: 40 on cube-double against 29 for FQL, and 43 on puzzle-3x3 against 30 for FQL. SORL is higher on antmaze-large, humanoidmaze-medium, antsoccer-arena and scene. The paper notes that SORL is not compute-matched with DeFlow 2601.10471 tab. 1 2601.10471 §4.1. Its per-action cost is still M flow calls plus the residual, against one to a few calls for shortcut policies [arxiv:2601.10471 tab. 3].

Continuous diffusion over token embeddings (language)

LangFlow is a continuous diffusion language model. Each token is an embedding vector, noise is added on a variance-preserving path indexed by a log noise-to-signal ratio, and a network predicts a token distribution at each position 2604.11748 §3.1. Sampling integrates an ODE from high noise to low noise with an Euler step, and the final tokens are the most likely ones 2604.11748 alg. 2. Its sampler is written in terms of that ratio, not the velocity of the robot variants above. Card: LangFlow: Continuous Diffusion Rivals Discrete in Language Modeling.

Two design choices carry the result. A learned Gumbel-shaped schedule concentrates noise levels where the loss changes, and the paper reports that a fixed uniform schedule spends most of its steps where the loss is near zero 2604.11748 §4.1. Self-conditioning, which feeds the previous step's prediction back in, is used with probability 0.25 during training and on at every step when sampling 2604.11748 §4.2 2604.11748 alg. 1. The paper reports that it matters much more for the continuous model than for discrete ones 2604.11748 §4.2 2604.11748 tab. 1.

Author-reported: LM1B perplexity 30.0 against 31.0 for MDLM, and OpenWebText perplexity 24.6 against 23.2 for MDLM and 25.2 for Duo 2604.11748 tab. 2. LangFlow is therefore not best on every benchmark. Its sampling budget matters: on LM1B its generative perplexity rises from 92.2 at 128 steps to 179.6 at 16 steps 2604.11748 app. NFE table. Its perplexity is an upper bound from an ODE with a random trace estimate, so it is not directly comparable with baselines evaluated another way [arxiv:2604.11748 app. Additional Evaluation Details] 2604.11748 §5.

Riemannian flow over unit-norm embeddings (language)

S-FLM gives each token a point on the unit sphere. The clean target is the normalised row of a learned embedding table, the prior is a uniform point on the sphere, and the noisy latent is the spherical interpolation between the two 2605.11125 §3 2605.11125 eq. 10. The gradient passes through that interpolation into the table, so the table is learned with the denoiser 2605.11125 alg. 1. The denoiser is trained with unweighted cross-entropy on the clean token at each position 2605.11125 §3 2605.11125 eq. 14. Sampling moves each latent along a geodesic, with a step set by the noise schedule. The velocity is a posterior-weighted sum of log maps toward every normalised embedding, and the final tokens are the argmax 2605.11125 eq. 15 2605.11125 alg. 2 2605.11125 eq. 13. Card: Language Modeling with Hyperspherical Flows.

Three choices carry most of the gain: a truncated range of the noise schedule, an adaptive density refit from recent losses, and top-1 velocity decoding. The paper's GSM8K ablation is cumulative. Accuracy goes from 1.2% with a linear schedule to 7.7% with truncation and 11.1% with the adaptive schedule. Keeping the activations on the sphere (S-arch) gives 12.4%, and top-1 decoding gives 18.0% 2605.11125 tab. 2 2605.11125 §3.2 [arxiv:2605.11125 §3.1]. The authors trained one model per configuration, so the gaps between rows are single-seed 2605.11125 §7.

Author-reported: on Sudoku, the truncated and adaptive variant reaches 94.8%, 85.2% and 45.0% at easy, medium and hard. MDLM gets 92.0, 77.1 and 30.2, and Duo gets 96.3, 84.7 and 58.4. The plain S-FLM row is below MDLM at all three levels 2605.11125 tab. 1. At temperature 0.1 on GSM8K, the paper reports about 18% for top-1 S-FLM, against about 33% for MDLM and 36% for Duo 2605.11125 §4.2 2605.11125 fig. 3. Training is slower per step with S-arch: 2.6 steps per second against 4.2 for the DiT on TinyGSM. Its GPU-hour count is 213.7, against 182.7 for MDLM 2605.11125 tab. 3.

The exact velocity sums over the whole vocabulary at each position and step, so its cost grows with vocabulary size. Top-k keeps only the k largest posterior entries 2605.11125 eq. 15 2605.11125 §3.1. The GSM8K results use 1024 sampling steps 2605.11125 tab. 2. The released sampling scripts default to 32, so a run at that default will not match the table sfm_sphere_arch_truncated_adaptive_no_renorm.sh.

When to use which

The papers' numbers are not directly comparable. The training-time RTC simulation uses Kinetix and the real tests use pi0.6. MoH adds its head to pi0 and pi0.5, which are 3B-class base models 2511.19433 §4.1, while the joint video-action model is evaluated on LIBERO and RoboCasa-GR1 with models trained from scratch. GR00T N1 reports on RoboCasa, DexMimicGen and GR-1 tasks with its own pretraining mix. DeFlow reports on OGBench and D4RL offline RL tasks, LangFlow reports language perplexity, and S-FLM reports GSM8K and Sudoku accuracy, with OpenWebText only as a frontier plot 2605.11125 §4.3 2605.11125 fig. 4. So the robot, RL and language numbers do not compare with each other, and the two language papers measure different things. MoH (99.0) and DiT4DiT (98.6) both report LIBERO averages near 99%, but from different starting points, so the gap says little. The motion-image head reports on LIBERO and RoboTwin with pi0 and pi0.5 2512.18007 tab. 1, and DualVLN reports navigation success on R2R-CE and VLN-PE 2512.08186 tab. 1 2512.08186 tab. 2, so neither can be ranked against the manipulation numbers above.

Implementation sketch

The shared core for the velocity variants is the flow-matching loss and the Euler sampler. Most of the papers that use it write time with noise at 0 and data at 1 2512.05964 alg. 1 2601.10471 alg. 1 2511.19433 §3.1 2512.18007 eq. 4. 2603.10448 uses the reverse, with time 1 for noise and 0 for data 2603.10448 alg. 1. The DualVLN code uses the reverse direction too, with its noise level at 1 for noise internvla_n1.py. GR00T N1's equations are internally inconsistent on this point (see Contradictions). The sketch below uses the first convention. Variants add their own parts: the training-time RTC variant sets the prefix time to 1 and masks its loss, the joint model gets its features from a video backbone at a fixed time, the motion-image variant adds a second loss of the same form on flow latents and sums it with the action loss [arxiv:2512.18007 eq. 7], the navigation head is conditioned on latent tokens from its planner, and DeFlow adds a stop-gradient base action, a residual and a penalty on its size. The multi-horizon variant applies the loss above to each horizon and adds a gate-weighted fusion and a balance term, so its training loss is a sum over horizons 2511.19433 §3.2. LangFlow does not fit this sketch: its training loss is token cross-entropy and its sampler works on a different noise coordinate; see its card for its pseudocode 2604.11748 alg. 1 2604.11748 alg. 2. S-FLM does not fit either. Its latents live on the unit sphere, its loss is token cross-entropy, and its velocity sums over the vocabulary; see its card for its pseudocode 2605.11125 alg. 1 2605.11125 alg. 2.

# Flow-matching loss  [arxiv:2512.05964 alg. 1]
# Time 0 is noise, time 1 is data
def flow_matching_loss(model, obs, actions):
    # Draw Gaussian noise with the shape of the action chunk  [alg. 1]
    noise = sample_standard_normal_like(actions)
    # Draw one flow time per example, uniform on [0, 1]  [alg. 1]
    time = sample_uniform_01(batch_size)
    # Interpolate between noise (time 0) and data (time 1)  [alg. 1]
    noisy = time * actions + (1 - time) * noise
    # Predict the velocity from the noisy chunk and time  [§4]
    predicted = model(obs, noisy, time)
    # Target velocity is data minus noise  [alg. 1]
    return mean((predicted - (actions - noise)) ** 2)


# Euler sampler from noise to data  [arxiv:2512.05964 alg. 1]
def sample(model, obs, shape, num_steps):
    # Start from noise  [alg. 1]
    x = sample_standard_normal(shape)
    # Step from time 0 to time 1  [alg. 1]
    dt = 1.0 / num_steps
    for i in range(num_steps):
        t = i * dt
        # Move along the predicted velocity  [alg. 1]
        x = x + dt * model(obs, x, t)
    return x

Contradictions

GR00T N1's equations disagree with themselves. Its text writes the interpolation as tau times the actions plus (1 minus tau) times the noise, the target as noise minus the actions, and the Euler update with a plus sign 2503.14734 §2.1 2503.14734 eq. 1. Taken literally, that integrates the wrong way. The later N1.7 code puts noise at time 0 and uses actions minus noise as the target, the same convention as the sketch above gr00t_n1d7.py gr00t_n1d7.py. The N1 model code was not in the checkout the card was made from, so this convention is taken from N1.7 and not checked for N1.

The papers use opposite time directions. With time 0 at noise and time 1 at data 2512.05964 alg. 1 2511.19433 §3.1 2601.10471 alg. 1, the velocity is data minus noise. The motion-image paper puts data at time 1 in its equation 4 and does not write the velocity, which follows from that equation 2512.18007 eq. 4. With time 0 at data and time 1 at noise 2603.10448 eq. 1–3, the velocity is noise minus data. The DualVLN code is in the second family: its noise level is 1 for noise, and its target is noise minus the waypoints [code: internnav/model/basemodel/internvla_n1/internvla_n1.py#L263-L286]. Both describe the same family of flow, but a model trained in one convention and sampled in the other will not produce valid actions. Check which convention a checkpoint uses before reusing its sampler. S-FLM's paper puts pure noise at alpha = 0, and its code reverses the time variable so that t = 1 is pure noise 2605.11125 §2.1 noise_schedules.py.

MoH's paper and code disagree on this point. The paper uses the first convention 2511.19433 §3.1, but the code puts noise at t = 1 and integrates with a negative step pi0_moh.py pi0_moh.py.

The flow-time distribution is also unstated in the MoH paper. Its code samples time from a Beta(1.5, 1) distribution rescaled into [0.001, 0.999] pi0_moh.py, and GR00T N1 uses a Beta(1.5, 1.0) rescaled by 0.999 2503.14734 §2.1, so the uniform sampler in the sketch above is one choice among several.

DeFlow's puzzle budget differs between paper and code. The appendix gives a budget of 0.0005 for puzzle-3x3 and puzzle-4x4 2601.10471 app. B.1, but the repository's README passes 0.005 for both README.md README.md. The card follows the paper and suggests checking with the authors before reproducing the puzzle numbers.

LangFlow's perplexity for the same model and dataset is 81.5 in one table and 92.2 in another. The self-conditioning table gives 81.5 for LM1B generative perplexity 2604.11748 tab. 1, and the main table gives 92.2 2604.11748 tab. 2. The paper's NFE table gives 92.24 at 128 steps 2604.11748 app. NFE table, which agrees with the main table. The card uses 92.2 and does not resolve the difference further.

LangFlow's sampler update may not match its paper. The card's reading of the released code's Euler step, in the z over sigma form, gives a coefficient on the current state that differs from Algorithm 2 unless the two alpha values are equal 2604.11748 alg. 2 model.py. The card did not run the code, so this is a discrepancy to check, not a confirmed bug.

S-FLM's truncated schedule is described in two ways. Its text says training uses only the higher noise levels, with the bound alpha* from eq. 17 2605.11125 §3.2. For a vocabulary of about 50k and width 768, that bound is 0.121 2605.11125 tab. 4. The released adaptive GSM8K script uses 0.121 as the upper end of its range [code: scripts/train/tinygsm/sfm_sphere_arch_truncated_adaptive_no_renorm.sh#L32]. The paper's ablation instead reports bounds of 0.869 and 0.879, and calls 0.879 alpha*(0.1) 2605.11125 tab. 7 2605.11125 app. C.6. The released fixed-truncation DiT script sets a lower bound of 0.869 and keeps the other end of the schedule [code: scripts/train/tinygsm/sfm_sphere_dit_truncated_fixed_no_renorm.sh#L28-L29]. The table does not state its convention, and the code has not been run to settle it.

Otherwise, none known. The other papers report success on different benchmarks, delays and base models, so their numbers do not conflict.

Papers

• Training-Time Action Conditioning for Efficient Real-Time Chunking: flow policy whose prefix is conditioned at training time, with the loss on the postfix only.
• DiT4DiT: Jointly Modeling Video Dynamics and Actions for Generalizable Robot Control: a video diffusion transformer and an action diffusion transformer, trained with two flow-matching losses.
• Mixture of Horizons in Action Chunking: one action head trained on several chunk lengths at once, fused by a per-step gate with a balance loss.
• GR00T N1: An Open Foundation Model for Generalist Humanoid Robots: a diffusion-transformer action head trained with flow matching, sampled in four steps for 16-action chunks, inside a VLA.
• DeFlow: Decoupling Behavior-Prior Modeling and Value Maximization for Offline Policy Extraction: a frozen multi-step flow prior with a small residual trained to raise Q under a squared-size budget.
• LangFlow: Continuous Diffusion Rivals Discrete in Language Modeling: continuous diffusion over token embeddings, trained with token cross-entropy and sampled with an Euler ODE solver.
• Robotic VLA Benefits from Joint Learning with Motion Image Diffusion: a second flow-matching head predicts optical-flow latents during training, summed with the action loss and unused at inference.
• Ground Slow, Move Fast: A Dual-System Foundation Model for Generalizable Vision-and-Language Navigation: a 7B planner and a flow-matching trajectory head that run asynchronously, with the head's 32 waypoints as the output.
• Language Modeling with Hyperspherical Flows: token embeddings as points on the unit sphere, a Riemannian flow trained with cross-entropy and sampled with geodesic Euler steps.