---
kind: concept
slug: flow-matching
title: Flow matching
summary: >-
  Trains a network to move noise to data along a learned path, then samples by integrating it, usually in a few steps. Robot variants differ in chunking, auxiliary heads and horizon heads. Navigation runs a flow head asynchronously, and offline RL keeps the flow as a frozen prior. Language variants diffuse token embeddings, on a line or on a sphere. Choose by task, retraining budget and step cost.
tags: [generative-models, robot-learning, navigation, offline-rl, language-modeling]
papers: ["2511.19433", "2512.05964", "2603.10448", "2503.14734", "2601.10471", "2604.11748", "2512.18007", "2512.08186", "2605.11125"]
related: [action-chunking, diffusion-inpainting, diffusion-models, vision-language-action-model, imitation-learning, offline-reinforcement-learning, residual-learning, continuous-text-diffusion, discrete-diffusion, noise-schedule, likelihood-based-text-evaluation, latent-diffusion, optical-flow]
status: draft
updated_at: 2026-10-31
---

## 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 [arxiv:2512.05964 §4]
[arxiv:2603.10448 §4.1] [arxiv:2603.10448 alg. 2] [arxiv: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 [arxiv:2512.05964 alg. 1] [arxiv:2603.10448 eq. 2–3]
[arxiv:2511.19433 §3.1] [arxiv: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 [arxiv: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
[arxiv: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 [arxiv:2604.11748 app. NFE table]
[arxiv:2605.11125 tab. 2], against four steps for GR00T N1 [arxiv: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
[arxiv: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 [arxiv:2503.14734 §2.1]. The paper reports 63.9 ms to sample a
16-action chunk on an L40 GPU in bf16 [arxiv:2503.14734 §2.1]. DiT4DiT reuses
this action DiT design [arxiv:2603.10448 §4.2]. Card: [GR00T N1: An Open Foundation Model for Generalist Humanoid Robots](/papers/2503.14734).

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] [arxiv: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 [arxiv:2503.14734 tab. 2]
[arxiv: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 [arxiv:2503.14734 §1] [code: gr00t/configs/model/gr00t_n1d7.py#L76].

### 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 [arxiv:2512.05964 §1] [arxiv: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 [arxiv:2512.05964 §4]
[arxiv:2512.05964 alg. 1]. Card: [Training-Time Action Conditioning for Efficient Real-Time Chunking](/papers/2512.05964).

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 [arxiv:2512.05964 §4] [arxiv: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
[arxiv:2512.05964 §5.1] [arxiv: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) [arxiv:2512.05964 §5.2]
[arxiv: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 [arxiv:2603.10448 §4.2]
[arxiv:2603.10448 §4.4]. Card: [DiT4DiT: Jointly Modeling Video Dynamics and Actions for Generalizable Robot Control](/papers/2603.10448).

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 [arxiv:2603.10448 §4.3]
[arxiv:2603.10448 app. A.1]. At inference, one pass of the video backbone
produces the features, then four Euler steps integrate the action velocity
[arxiv:2603.10448 app. A.1] [arxiv: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 [arxiv:2603.10448 tab. 1] [arxiv: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 [arxiv:2603.10448 §5.4]
[arxiv: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 [arxiv:2603.10448 §4.3]
[code: DiT4DiT/model/modules/vlm/Cosmos25.py#L162].

### 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
[arxiv:2512.18007 §3.2] [arxiv: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 [arxiv:2512.18007 eq. 7] [arxiv: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 [arxiv:2512.18007 §3.3]. Card:
[Robotic VLA Benefits from Joint Learning with Motion Image Diffusion](/papers/2512.18007).

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% [arxiv: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
[arxiv:2512.18007 tab. 1] [arxiv:2512.18007 tab. 2]. The gains are small on
LIBERO and come from one seed per setting, with no intervals reported
[arxiv: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 [arxiv:2511.19433 §3.2]
[arxiv: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 [arxiv:2511.19433 §4.1].

Each horizon is trained with the base policy's own objective, which for
flow-matching models is velocity matching [arxiv:2511.19433 §3.1]
[arxiv: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 [arxiv:2511.19433 §3.2]
[arxiv:2511.19433 fig. 3]. Card: [Mixture of Horizons in Action Chunking](/papers/2511.19433).

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 [arxiv:2511.19433 §3.3] [arxiv:2511.19433 alg. 1]. The paper
claims 2.5 times the default throughput [arxiv:2511.19433 §1], but the sweep is
only plotted, so the numbers are not in the text [arxiv: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 [arxiv:2511.19433 tab. 1]. On pi0.5, a single horizon of 30 gives
97.7 and a stride of 3 gives 99.0 [arxiv: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
[arxiv: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 [arxiv:2512.08186 §3.1] [arxiv:2512.08186 §3.2]
[arxiv: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 [arxiv:2512.08186 §3.2] [arxiv:2512.08186 eq. 1–3]. Card:
[Ground Slow, Move Fast: A Dual-System Foundation Model for Generalizable Vision-and-Language Navigation](/papers/2512.08186).

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] [arxiv: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 [arxiv:2512.08186 §5.2] [code: internnav/model/basemodel/internvla_n1/internvla_n1.py#L349-L435]
[code: internnav/model/utils/vln_utils.py#L129-L131]. Author-reported: 64.3%
success on R2R-CE val-unseen with RGB only, against 56.9% for StreamVLN
[arxiv: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
[arxiv:2512.08186 §5.2]. The asynchronous design is needed for that behaviour
[arxiv: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 [arxiv: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] [arxiv: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] [arxiv:2601.10471 app. B.1]. Card: [DeFlow: Decoupling Behavior-Prior Modeling and Value Maximization for Offline Policy Extraction](/papers/2601.10471).

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 [arxiv:2601.10471 app. B.1]. The penalty is enforced on minibatches,
so the paper gives no hard per-state guarantee [arxiv:2601.10471 §3.2]
[arxiv: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 [arxiv:2601.10471 tab. 1]
[arxiv: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 [arxiv: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
[arxiv: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](/papers/2604.11748).

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
[arxiv: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 [arxiv:2604.11748 §4.2] [arxiv:2604.11748 alg. 1]. The
paper reports that it matters much more for the continuous model than for
discrete ones [arxiv:2604.11748 §4.2] [arxiv: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 [arxiv: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 [arxiv: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] [arxiv: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 [arxiv:2605.11125 §3] [arxiv:2605.11125 eq. 10]. The gradient passes
through that interpolation into the table, so the table is learned with the
denoiser [arxiv:2605.11125 alg. 1]. The denoiser is trained with unweighted
cross-entropy on the clean token at each position [arxiv:2605.11125 §3]
[arxiv: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
[arxiv:2605.11125 eq. 15] [arxiv:2605.11125 alg. 2] [arxiv:2605.11125 eq. 13].
Card: [Language Modeling with Hyperspherical Flows](/papers/2605.11125).

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% [arxiv:2605.11125 tab. 2] [arxiv:2605.11125 §3.2] [arxiv:2605.11125
§3.1]. The authors trained one model per configuration, so the gaps between
rows are single-seed [arxiv: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 [arxiv: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
[arxiv:2605.11125 §4.2] [arxiv: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 [arxiv: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 [arxiv:2605.11125 eq. 15] [arxiv:2605.11125 §3.1]. The GSM8K results use
1024 sampling steps [arxiv:2605.11125 tab. 2]. The released sampling scripts
default to 32, so a run at that default will not match the table
[code: scripts/sample/tinygsm/sfm_sphere_arch_truncated_adaptive_no_renorm.sh#L12].

## When to use which

| Situation | Use | Why |
|---|---|---|
| You need a flow action head with no change to its loss or sampler, as a starting point or baseline | Standard flow action head (GR00T N1) | The plain recipe: 16-action chunks, Beta-distributed flow time and four Euler steps [arxiv:2503.14734 §2.1]. Its reported 63.9 ms per chunk on an L40 is one data point, not a guarantee [arxiv:2503.14734 §2.1] |
| The policy is already trained, or you cannot add a per-action time input | Inference-time RTC | The training-time variant needs a per-action flow timestep, and the paper gives no recipe for architectures without per-token modulation [arxiv:2512.05964 §4] [arxiv:2512.05964 §6] |
| You can retrain, and the inference delay is 2 steps or more | Training-time RTC | In simulation it beats the inference-time method at delays of 2 and above, and its advantage grows with the delay; in the real tests it runs at lower compute [arxiv:2512.05964 §5.1] [arxiv:2512.05964 §5.2] |
| The inference delay is 0 or 1 step in simulation | Either; the simulated data slightly favour inference-time RTC here | Training-time RTC was slightly lower at delays 0 and 1, which the authors attribute to fewer supervised first actions [arxiv:2512.05964 §5.1] |
| You want to reuse a pretrained video generator as the policy backbone and can afford about 2.2B trainable parameters | Joint video-action model | Trained from scratch on each benchmark's action data, it reached the highest reported average on LIBERO and RoboCasa-GR1 [arxiv:2603.10448 tab. 1] [arxiv:2603.10448 tab. 2] [arxiv:2603.10448 tab. 3] |
| You have a flow-matching chunk policy, can retrain its action head, and want a gain at a fixed chunk length | Multi-horizon action head | Reported gains of 1.3 points on LIBERO average for both pi0 and pi0.5 [arxiv:2511.19433 tab. 1]. Expect extra training compute, and each sample runs one suffix pass per horizon [arxiv:2511.19433 §1] [code: src/openpi/models/pi0_moh.py#L308-L311] |
| The best chunk length differs across tasks or suites, and you do not want to tune it per task | Multi-horizon action head | On pi0 the authors saw longer horizons help long-horizon suites and hurt short ones [arxiv:2511.19433 §1] [arxiv:2511.19433 fig. 1]. The gate learns how much to trust each length at each step [arxiv:2511.19433 §3.2] |
| You have a pi-series VLA and want an auxiliary training signal about motion, with no change to inference, and you can retrain | Auxiliary motion-image head (2512.18007) | The motion head is dropped at inference, so speed is unchanged [arxiv:2512.18007 §4.3]. Its motion target beat a future-image target by 1.8 points and a language target by 2.4 on LIBERO for pi0.5, from single-seed runs [arxiv:2512.18007 tab. 3] [arxiv:2512.18007 §4.2] |
| You need navigation from language, with a VLM planner that runs now and then and a local trajectory head that must react to new frames | Flow trajectory head in a dual-system navigator (DualVLN) | The planner runs at 0.7 s per call and the head at 0.03 s on one RTX 4090, both author-measured [arxiv:2512.08186 §5.2]. Its results on R2R-CE and VLN-PE are simulation only, and the sampler and aggregation rule are set in code [arxiv:2512.08186 tab. 1] [arxiv:2512.08186 §5.2] |
| Control frequency matters more than success rate | Not the video-backbone model | Its reported control rate was 6 Hz on one A100, against 9 Hz and 13 Hz for the baselines [arxiv:2603.10448 tab. 3] |
| Offline RL from a fixed log, where you want to keep a multi-step generator as the behaviour prior and avoid backpropagating through its sampler | Residual refinement on a frozen flow prior (DeFlow) | The prior is trained only on logged actions and the residual carries the value improvement [arxiv:2601.10471 §3.2]. Reported gains over FQL on cube-double and puzzle-3x3 [arxiv:2601.10471 tab. 1]. Budget per task is a tuning choice, and the code and paper disagree on one puzzle value [arxiv:2601.10471 app. B.1] [code: README.md#L86] |
| Offline RL where a one-step policy is acceptable and the budget for inference compute is tight | Not DeFlow by default | Its cost per action is M flow calls plus the residual, against one to a few calls for shortcut policies [arxiv:2601.10471 tab. 3]. Its timing gap to FQL is small on one GPU [arxiv:2601.10471 tab. 4] |
| You model language and want a continuous, editable latent space, and you can afford many sampling steps | Continuous text diffusion (LangFlow) | Competitive with masked diffusion on LM1B perplexity [arxiv:2604.11748 tab. 2], and the paper motivates continuous latents by controllable and few-step generation, which discrete diffusion gives up [arxiv:2604.11748 §1]. Expect many steps: 92.2 generative perplexity at 128 steps, 179.6 at 16 [arxiv:2604.11748 app. NFE table] |
| You want a continuous language flow with no vocabulary-sized one-hot latent, trained with plain token cross-entropy, and you can afford top-1 decoding and many steps | Riemannian flow over unit-norm embeddings (S-FLM) | The latent is a point on the sphere, and the paper says earlier continuous flow LMs on one-hot vectors were below 1% on GSM8K [arxiv:2605.11125 §1] [arxiv:2605.11125 §3]. Its best reported GSM8K accuracy is 18.0%, against 0.2% for CANDI and 0.3% for FLM [arxiv:2605.11125 tab. 2] |
| You need a continuous language model that is competitive at low sampling temperature | Not S-FLM | At T = 0.1 its top-1 variant reaches about 18% on GSM8K, against about 33% for MDLM and 36% for Duo [arxiv:2605.11125 §4.2] [arxiv:2605.11125 fig. 3]. The authors suggest that continuous flows fit a continuous density to discrete data, and that the Python solutions are strongly left-to-right [arxiv:2605.11125 §7] |
| You need a few-step language sampler | No variant here, as reported | LangFlow drops from 92.2 generative perplexity at 128 steps to 179.6 at 16 [arxiv:2604.11748 app. NFE table]. S-FLM's headline uses 1024 steps [arxiv:2605.11125 tab. 2] |
| You need a training recipe for LangFlow | Not yet | The training code is not released, so the training loss must be taken from the paper's Algorithm 1 [arxiv:2604.11748 alg. 1] [code: README.md] |

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 [arxiv: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 [arxiv:2605.11125 §4.3]
[arxiv: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 [arxiv:2512.18007 tab. 1], and DualVLN reports navigation success
on R2R-CE and VLN-PE [arxiv:2512.08186 tab. 1] [arxiv: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 [arxiv:2512.05964 alg. 1] [arxiv:2601.10471 alg. 1] [arxiv:2511.19433 §3.1]
[arxiv:2512.18007 eq. 4]. 2603.10448 uses the reverse, with time 1 for noise and 0 for data
[arxiv:2603.10448 alg. 1]. The DualVLN code uses the reverse direction too, with
its noise level at 1 for noise [code: internnav/model/basemodel/internvla_n1/internvla_n1.py#L263-L286]. 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 [arxiv: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
[arxiv:2604.11748 alg. 1] [arxiv: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
[arxiv:2605.11125 alg. 1] [arxiv:2605.11125 alg. 2].

```pseudocode
# 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
[arxiv:2503.14734 §2.1] [arxiv: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
[code: gr00t/model/gr00t_n1d7/gr00t_n1d7.py#L233-L235]
[code: gr00t/model/gr00t_n1d7/gr00t_n1d7.py#L355]. 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 [arxiv:2512.05964 alg. 1] [arxiv:2511.19433 §3.1] [arxiv: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
[arxiv:2512.18007 eq. 4]. With time 0 at data
and time 1 at noise [arxiv: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
[arxiv:2605.11125 §2.1] [code: noise_schedules.py#L59-L60].

MoH's paper and code disagree on this point. The paper uses the first
convention [arxiv:2511.19433 §3.1], but the code puts noise at t = 1 and
integrates with a negative step [code: src/openpi/models/pi0_moh.py#L282-L291]
[code: src/openpi/models/pi0_moh.py#L449].

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]
[code: src/openpi/models/pi0_moh.py#L283], and GR00T N1 uses a Beta(1.5, 1.0)
rescaled by 0.999 [arxiv: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 [arxiv:2601.10471 app. B.1], but
the repository's README passes 0.005 for both [code: README.md#L86]
[code: README.md#L88]. 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 [arxiv:2604.11748 tab. 1], and the main table gives 92.2
[arxiv:2604.11748 tab. 2]. The paper's NFE table gives 92.24 at 128 steps
[arxiv: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 [arxiv:2604.11748 alg. 2] [code: langflow/model.py#L412-L420]. 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
[arxiv:2605.11125 §3.2]. For a vocabulary of about 50k and width 768, that bound
is 0.121 [arxiv: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) [arxiv:2605.11125 tab. 7] [arxiv: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](/papers/2512.05964): 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](/papers/2603.10448): a video diffusion transformer and an action diffusion transformer, trained with two flow-matching losses.
- [Mixture of Horizons in Action Chunking](/papers/2511.19433): 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](/papers/2503.14734): 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](/papers/2601.10471): 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](/papers/2604.11748): 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](/papers/2512.18007): 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](/papers/2512.08186): 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](/papers/2605.11125): token embeddings as points on the unit sphere, a Riemannian flow trained with cross-entropy and sampled with geodesic Euler steps.