Few-Step Distillation for Text-to-Image Generation: A Practical Guide

ArXiv: 2512.13006

🎯 Pitch

Distilling an 8B-parameter text-to-image model down to just two steps can match the original teacher's quality—but only with the right method. This study reveals a brutal tradeoff: sCM achieves this parity at two steps but collapses at one, while MeanFlow needs four steps to shine but then surpasses all competitors on fidelity benchmarks.

---

1. Executive Summary

This paper presents the first systematic study adapting and comparing state-of-the-art diffusion–distillation techniques for open-ended text-to-image generation, using FLUX.1-lite (8B parameters) as the teacher model and evaluating on GenEval and DPG-Bench. The authors cast existing methods into a unified framework, focusing on simplified Continuous-time Consistency Models (sCM) (consistency distillation with TrigFlow reparameterization and teacher-guided velocity targets) and MeanFlow (trajectory distillation that learns average velocity between timesteps via Jacobian-vector products with classifier-free guidance blending), examining their behavior across 1–4 network function evaluations. sCM achieves 52.81% overall on GenEval at NFE=2—matching the teacher's 53.58%—while MeanFlow reaches 80.03 on DPG-Bench at NFE=4, surpassing sCM's 77.85, but collapses to 0.78% on GenEval at NFE=1, establishing a stark tradeoff: sCM is the optimal choice for extreme few-step regimes (NFE ≤ 2) whereas MeanFlow requires NFE=4 to produce superior fidelity, with both methods only recovering teacher-level performance when their respective minimum step thresholds are met.

2. Context and Motivation

The Core Problem: Diffusion Models Are Too Slow for Interactive Applications

Modern text-to-image diffusion models have achieved remarkable generation quality—FLUX, Qwen-Image, and Imagen can produce photorealistic, high-resolution images from complex natural language descriptions. However, this capability comes with a severe practical limitation: they require an iterative denoising process that typically consumes hundreds of network function evaluations to gradually transform Gaussian noise into a coherent image. Each NFE corresponds to one forward pass through a large neural network (often billions of parameters), making the generation process both computationally expensive and slow.

This latency bottleneck fundamentally restricts deployment in scenarios where users expect near-instantaneous visual feedback. The paper explicitly identifies several affected application domains: interactive design tools (where a designer iterates rapidly on prompts and needs immediate previews), dynamic game content generation (where assets must be created on-the-fly in response to player actions), and augmented reality (where virtual content must be synthesized at frame rate to blend with the real world). In all these cases, the hundreds-of-NFEs regime of standard diffusion is simply non-viable.

The practical importance is amplified by the sheer parameter counts of modern T2I models. FLUX.1-lite, the teacher model studied here, uses 8 billion parameters—hardware that can run such a model at all is expensive, and running it hundreds of times per image multiplies that cost. For a single 1024×1024 image, a 500-NFE generation might require minutes on consumer hardware, eliminating any possibility of real-time interaction. This creates a direct economic tension: the models that produce the best images are also the most expensive and slowest to run, making their deployment in cost-sensitive or latency-sensitive contexts impractical.

The theoretical significance of this problem extends beyond the practical deployment concerns. The iterative denoising process is not merely an implementation detail of diffusion models—it is fundamental to how they learn to generate. During training, these models are exposed to noisy images at every level of corruption and learn to reverse the diffusion process step-by-step. Asking a model to jump directly from pure noise to a clean image in a single step is conceptually a much harder learning problem. Understanding how to compress this multi-step process into 1–4 steps while preserving quality—and understanding why different compression strategies succeed or fail at different step counts—is a fundamental scientific question about the geometry of learned diffusion trajectories and the tradeoffs between trajectory straightness, step count, and output fidelity.

The Field Had Three Competing Paradigms—But No Systematic Comparison for T2I

Prior to this paper, the few-step generation literature had coalesced around three broad methodological families:

Distribution Distillation methods train a few-step student model to match the output distribution of a pre-trained teacher. The student never sees the teacher's intermediate denoising steps—it only learns to produce samples that are statistically indistinguishable from the teacher's final outputs. Representative methods include Distribution Matching Distillation (DMD, DMDv2), which minimizes a distributional divergence between student and teacher samples while incorporating a regression or GAN loss, and Latent Adversarial Diffusion Distillation (LADD), which frames the distillation as an adversarial game in latent space where a discriminator tries to distinguish student samples from teacher samples. These methods have seen notable practical success: Qwen-Image-Lightning uses DMD, and SD3-Turbo and FLUX.1 Kontext use LADD. Their key characteristic is that they treat the generation process as a black box—the student only needs to replicate the endpoint of the teacher's sampling trajectory, not the trajectory itself.

Trajectory-based Distillation methods take a fundamentally different approach. Rather than only matching the final output distribution, they train the student to predict segments of the teacher's sampling trajectory in fewer steps. The intuition is that by learning the dynamics of the generation process—not just its endpoint—the student can more faithfully reproduce the teacher's behavior, including complex elements like classifier-free guidance interactions. This category includes the three methods that form the core of this paper's investigation: sCM (simplified Continuous-time Consistency Models), MeanFlow, and IMM (Inductive Moment Matching). The critical theoretical difference is that trajectory methods impose consistency along the entire diffusion path, not just at the final sample, which in principle should yield better step-count scaling.

From-scratch Training methods, of which IMM is the primary representative studied here, abandon the teacher altogether and train a few-step model directly on data using specialized objectives. IMM enforces a distributional consistency constraint: samples projected from different noise levels to a target time must converge to the same distribution, measured via Maximum Mean Discrepancy rather than KL divergence for training stability. This bypasses the need for a teacher model entirely, which is both a strength (no expensive teacher required at training time) and a potential weakness (no access to the teacher's learned trajectory geometry).

The Critical Gap: T2I Results Only Existed for Distribution Distillation

When this paper was written, the publicly available results for trajectory-based and from-scratch few-step methods painted a striking but incomplete picture. DMD and LADD—the distribution distillation methods—had been successfully scaled to text-to-image generation with documented, competitive results on standard T2I benchmarks. But sCM, MeanFlow, and IMM had only demonstrated results on class-conditional ImageNet generation, a task that differs from open-ended text-to-image generation in fundamental ways:

• Discrete vs. free-form conditioning: ImageNet uses 1,000 fixed class labels. T2I models must condition on arbitrary natural language prompts spanning an enormous semantic range.
• Scale of the conditioning space: A class label is a one-hot vector. A text prompt encodes complex compositional semantics (multiple objects, attributes, spatial relationships, artistic styles) that the model must disentangle and faithfully render.
• Evaluation complexity: Class-conditional generation can be evaluated with simple metrics like FID and Inception Score that primarily measure sample quality and class-conditional diversity. T2I evaluation requires assessing text-image alignment—whether the generated image actually depicts what the prompt describes—which is a fundamentally harder and more nuanced evaluation problem, typically requiring benchmarks like GenEval and DPG-Bench that measure compositional understanding across attributes, relations, colors, counts, and positions.

The gap between ImageNet-scale results and T2I applicability is not merely a matter of scale. The conditioning mechanism in T2I models (typically cross-attention between text embeddings and image features) interacts with the denoising trajectory in complex ways. A trajectory distillation method that works well when conditioned on a single class token might behave very differently when conditioning on a 77-token text embedding with rich syntactic and semantic structure. The geometry of the learned trajectories—how "straight" they are, how they respond to classifier-free guidance, whether they support large step jumps—could be qualitatively different in the T2I setting.

Why Trajectory Methods Are Theoretically Promising but Practically Unvalidated

The paper's motivation for focusing specifically on sCM and MeanFlow (and conducting a theoretical analysis of IMM as well) stems from several theoretical properties that make trajectory-based methods particularly promising for few-step generation:

Consistency along the entire path. Distribution distillation methods only ensure that the student's final sample matches the teacher's final sample. If the student's intermediate states (at, say, NFE=2 or NFE=4) diverge from the teacher's trajectory, the student has no mechanism to correct course—it only receives supervision at the endpoint. Trajectory methods, by enforcing consistency at every point along the path, provide much denser supervision and, in principle, should learn trajectories that are more amenable to coarse discretization. This is the core argument for why sCM can maintain structural coherence even at NFE=1 (visible in Figure 1's giraffe and buses examples): the consistency training has taught the model to map any point on the path directly to the clean image, so even a single large step stays on-target.

Classifier-free guidance integration. Text-to-image models rely heavily on classifier-free guidance—interpolating between conditional and unconditional predictions with a guidance scale—to improve prompt adherence. This creates complex trajectory dynamics that are not present in unconditional models. Trajectory distillation methods that learn the full path (including the guidance interaction) may be better positioned to capture these dynamics than distribution methods that only see the final guided output. The paper's experiments with MeanFlow's "Improved CFG" variant (Section 4.2.2) directly test this hypothesis, showing that better alignment of the distillation target with standard CFG practice boosts GenEval from 48.65% to 51.41%.

Theoretical connections between methods. A major contribution of the paper is establishing formal relationships between these methods that were not previously articulated (Section 3): Flow Matching is a special case of MeanFlow when the reference time equals the current time; sCM and TrigFlow are interconvertible without retraining; MeanFlow's gradient is equivalent to sCM's gradient when the EMA target network is synchronized with the online network; and IMM reduces to discrete-time consistency models when using single-particle estimates and squared Euclidean distance kernels. These connections are not just theoretical curiosities—they provide a unified framework for understanding what distinguishes these methods (use of EMA targets, choice of time parameterization, single vs. paired sampling) and what design choices actually matter for practical performance. Before this paper, these methods appeared as independent proposals with different names, different notation, and different conceptual framings; by showing their mathematical relationships, the paper enables practitioners to reason about which components are essential and which are interchangeable.

Positioning: A Practical Guide, Not a New Method

The paper explicitly positions itself not as proposing a novel distillation algorithm, but as providing the first systematic empirical study of how trajectory-based distillation methods perform when adapted to text-to-image generation. The abstract frames this clearly: "the first systematic study that adapts and compares state-of-the-art distillation techniques on a strong T2I teacher model."

This positioning addresses a concrete need in the research community. The rapid pace of few-step generation research has produced many methods with strong ImageNet results, but practitioners looking to deploy fast T2I systems face an ambiguous landscape: which method should they implement? What modifications are needed for T2I conditioning? What step counts are achievable? What are the failure modes? Without a systematic comparison under controlled conditions—same teacher, same dataset, same evaluation benchmarks—there is no way to answer these questions from existing literature because different papers use different base models, different datasets, and different (often incomparable) evaluation protocols.

The paper also acknowledges a negative space in its coverage: IMM receives theoretical treatment in Section 2.3 and Section 3.4 (showing its relationship to CM) but does not receive experimental evaluation on T2I. The primary experiments focus on sCM and MeanFlow, with IMM left as theoretical context. This is a deliberate scope limitation rather than an omission—the paper's practical contribution is the adaptation and benchmarking of the two trajectory methods judged most promising for T2I, with IMM's theoretical connections documented to provide a complete picture of the relationship landscape.

The Specific Practical Challenges the Paper Tackles

Beyond the high-level motivation, the paper addresses several concrete technical obstacles that arise when adapting continuous-time trajectory methods to T2I:

Training instability from timestep normalization. Section 4.2.1 documents a specific failure mode: when the diffusion transformer's timestep input ranges from 0–1000 (the standard convention in many diffusion implementations), "the gradient norm increases continuously during training, eventually leading to collapse." This is a practical implementation detail that would derail any attempt to apply sCM to FLUX without intervention. The solution—teacher-student distillation to rescale timesteps to [0,1]—is validated by showing the rescaled teacher matches the original's GenEval performance (Table 1, first two lines). This is the kind of practical knowledge that existing papers (focused on ImageNet from-scratch training) simply don't address.

Architectural changes for dual-time inputs. MeanFlow requires the model to condition on two time variables (current time t and reference time r) rather than just one. The standard FLUX.1-lite architecture encodes a single timestep via sinusoidal embeddings and MLP projection for AdaLN modulation layers. Section 4.2.2 describes the concrete architectural modification: cloning the time embedding branch (initialized with shared weights) to process the time differential (t−r), then summing the two branches' outputs before feeding to AdaLN. This is a minimal, weight-efficient modification that preserves the pretrained teacher's knowledge while enabling the new conditioning regime. Again, this is practical engineering knowledge that is essential for reproduction but absent from method papers focused on theoretical derivations.

The distillation vs. from-scratch choice for MeanFlow. While MeanFlow can be formulated as a from-scratch training objective (Algorithm 1), the paper empirically finds it "significantly more effective as a distillation technique" (Algorithm 2). The reasoning is concrete: the from-scratch target velocity v = e − x is an "unbiased but highly stochastic estimator," introducing substantial variance, whereas the teacher's instantaneous velocity represents a "denoised, deterministic approximation of the optimal transport path." This is an important practical finding: MeanFlow's theoretical framework is elegant, but in practice it benefits enormously from access to the teacher's converged vector field, allowing it to focus on "rectifying the curvature of the trajectory via the Jacobian correction term, rather than learning the data distribution from scratch."

Hyperparameter sensitivity. The paper's experimental section reveals non-obvious hyperparameter choices that significantly impact results. The loss function's exponent γ (where the loss is ∥Δ∥^(2γ)) is empirically found to work best at γ=2 (effectively a fourth-power loss) rather than the p=1 or p=0.5 recommended in the original MeanFlow paper—this single change boosts GenEval from 44.04% to 48.65%. Similarly, the Improved CFG mixing scale κ provides another substantial boost to 51.41%. These findings underscore that trajectory distillation methods, while theoretically well-founded, require careful empirical tuning in the T2I domain, and that default hyperparameters from ImageNet-scale work don't necessarily transfer.

Summary: The Paper Fills a Methodological Gap Between Theory and Practice

The paper's motivation can be distilled to one central observation: trajectory-based few-step methods have strong theoretical properties and promising ImageNet results, but their behavior in the text-to-image domain—which is where most real-world deployment happens—is a black box. No prior work has adapted sCM or MeanFlow to a large-scale T2I teacher, established the necessary architectural and hyperparameter modifications, compared them head-to-head under identical conditions, or characterized their step-count vs. quality tradeoffs on standard T2I benchmarks. This paper fills that gap, providing both the methodological analysis (connecting these methods theoretically) and the practical engineering (code, training recipes, evaluation results) needed for the community to make informed decisions about which method to use and how to implement it. The framing as a "practical guide" is apt: the contribution is not a new equation but a systematic map of an underexplored territory, with clear signposts about where each method succeeds, where it fails, and what it takes to make it work.

3. Technical Approach

3.1 Reader Orientation

This paper builds a comparative analysis and engineering framework for accelerating text-to-image diffusion models to generate high-quality images in 1–4 forward passes instead of hundreds. The system being built is not a single novel algorithm but rather two parallel distillation pipelines—one based on simplified Continuous-time Consistency Models (sCM) and one based on MeanFlow—each adapted from prior theoretical work to work with the FLUX.1-lite (8B parameter) teacher model for open-ended text-to-image generation. The problem it solves is practical deployment: how do you take a state-of-the-art but slow T2I model and produce a student that runs 50–500× faster while preserving output quality? The shape of the solution is empirical: systematically identify the architectural modifications, hyperparameter settings, and training recipes needed for each method, compare them head-to-head under identical conditions, and characterize where each succeeds and fails as a function of the number of sampling steps.

3.2 Big-Picture Architecture (Diagram in Words)

The system has two complete distillation pipelines, both following a teacher-student paradigm with the same 8B-parameter FLUX.1-lite as teacher:

Pipeline 1 — sCM Distillation:

• A teacher model (original FLUX.1-lite) generates images via standard multi-step diffusion, providing classifier-free guided velocity predictions.
• A timestep-rescaled student is created first: the original teacher's timestep range [0, 1000] is normalized to [0, 1] via a preliminary distillation step that matches the teacher's output distribution at proportionally scaled timesteps. This student has identical architecture to the teacher except it accepts timesteps in [0, 1].
• During sCM training, the rescaled student receives noisy images at arbitrary timestep t, computes its own velocity prediction, and is supervised by the teacher's classifier-free guided velocity at that same t. The loss enforces consistency: the student must learn to map from any noise level directly to the clean image in one step, with the teacher's trajectory providing the target.

Pipeline 2 — MeanFlow Distillation:

• The same timestep-rescaled teacher (now accepting t ∈ [0, 1]) serves as the velocity oracle.
• A MeanFlow student is initialized from the rescaled teacher but with an architectural modification: it has dual timestep inputs—it conditions on both the current time t and the time differential (t−r) where r is a reference time. This is implemented by cloning the sinusoidal embedding + MLP projection branch and summing outputs.
• During MeanFlow training, the student receives a noisy sample at time t, computes its average velocity prediction between t and r (where r < t), and the target is constructed from the teacher's instantaneous velocity at t minus a Jacobian correction term that accounts for trajectory curvature. The loss minimizes the discrepancy between the student's average velocity and this corrected target.

Shared evaluation infrastructure:

• Both students are evaluated on GenEval and DPG-Bench benchmarks at NFE = {1, 2, 4} using standard samplers appropriate to their formulation (TrigFlow-based for sCM, flow-based for MeanFlow).
• The codebase (Section 5) is built on Hugging Face Diffusers, uses DeepSpeed ZeRO with bfloat16 mixed precision and gradient checkpointing, and operates in the pretrained AutoencoderKL latent space (16-channel, 8× downsampling).

3.3 Roadmap for the Deep Dive

• First, I will explain the timestep rescaling procedure—since both pipelines depend on this preliminary step, and without it, training collapses.
• Second, I will detail the sCM distillation pipeline: how the TrigFlow formulation is adapted, what the training objective computes, and why teacher-guided velocity targets are used instead of standard consistency training.
• Third, I will detail the MeanFlow distillation pipeline: the dual-timestep architectural modification, the Jacobian-vector product mechanism that constructs the target, the distillation vs. from-scratch choice, and the hyperparameter innovations (fourth-power loss, Improved CFG).
• Fourth, I will walk through the theoretical relationships established in Section 3—Flow Matching as a special case of MeanFlow, TrigFlow–FM interconversion, sCM–MeanFlow gradient equivalence, and IMM–CM reduction—since these provide the conceptual scaffolding for understanding why the two pipelines differ and what design choices fundamentally distinguish them.
• Fifth, I will cover the evaluation protocol and codebase infrastructure that enables reproducible comparison.

This order ensures you understand the concrete engineering (timestep rescaling) before seeing how each method builds on it, then provides the theoretical lens to interpret the empirical results.

3.4 Detailed, Sentence-Based Technical Breakdown

This is primarily an empirical adaptation and comparison paper whose core contribution is a systematic engineering study of how to make trajectory-based few-step distillation methods work for text-to-image generation with a large-scale transformer teacher, accompanied by theoretical analysis that unifies these methods into a common mathematical framework.

---

3.4.1 Preliminary: Timestep Rescaling via Teacher–Student Distillation

Before either sCM or MeanFlow training can begin, the paper identifies and solves a critical practical obstacle: the FLUX.1-lite teacher model uses a timestep range of [0, 1000], but this range causes training instability when used with continuous-time consistency objectives.

The instability problem. Section 4.2.1 reports a specific failure mode observed during initial sCM training attempts: "when the Diffusion Transformer's timestep input ranges from 0 to 1000, the gradient norm increases continuously during training, eventually leading to collapse." This is a non-obvious practical issue—the standard discrete-time diffusion convention of 0–1000 timesteps (inherited from DDPM) works fine for multi-step sampling, but the continuous-time consistency objective (which involves derivatives with respect to time) appears sensitive to the numerical scale of the time variable. The paper does not provide a rigorous theoretical explanation for why this happens, but the empirical observation is clear and the fix is validated experimentally.

The rescaling procedure. The solution is to create a new student model that operates with timesteps normalized to the range [0, 1]. This is done through a preliminary distillation step:

1. Take the original FLUX.1-lite as the teacher (timesteps in [0, 1000]).
2. Initialize a student model with identical architecture except configured to accept timesteps in [0, 1].
3. For each training sample, feed the same image and text prompt to both teacher and student, but with proportionally scaled timesteps: if the teacher receives timestep 500, the student receives 0.5; if the teacher receives 250, the student receives 0.25, etc.
4. Train by minimizing the smooth L1 loss between the teacher's output and the student's output.

The training is performed at 1024×1024 resolution with a total batch size of 128 for 120,000 iterations.

Validation. The first two lines of Table 1 show that this rescaling does not compromise generation quality—the rescaled teacher achieves GenEval scores essentially identical to the original. This is a critical validation: it confirms that the [0, 1] normalization is merely a change of numerical representation that preserves the model's learned denoising capability. The rescaled model then serves as the base for both sCM and MeanFlow distillation pipelines.

Why this matters beyond this paper. The timestep rescaling issue is not specific to FLUX.1-lite or sCM. Any attempt to apply continuous-time consistency training to a diffusion model originally trained with discrete-time conventions will encounter this scale mismatch. The paper's solution—teacher-student distillation at proportionally scaled timesteps—is a general recipe that other practitioners can follow when adapting similar methods to different base models.

---

3.4.2 sCM Distillation: Consistency Training with Teacher-Guided Velocity Targets

The sCM pipeline trains a student model to map from any noise level directly to the clean image in a single step, using the teacher's classifier-free guided velocity as the regression target.

The TrigFlow formulation. sCM operates in the TrigFlow framework, which parameterizes the noisy input at time t as:

$\boldsymbol{x}_{t,\texttt{Trig}} = \cos(t_{\texttt{Trig}})\boldsymbol{x}_0 + \sin(t_{\texttt{Trig}})\boldsymbol{z}$

where $\boldsymbol{x}_{t,\texttt{Trig}}$ is the noisy sample at TrigFlow time $t_{\texttt{Trig}}$, $\boldsymbol{x}_0$ is the clean image, and $\boldsymbol{z} \sim \mathcal{N}(0, \mathbf{I})$ is standard Gaussian noise.

What this computes: the noisy sample as an interpolation between clean image and pure noise, with $\cos(t)$ controlling the signal strength and $\sin(t)$ controlling the noise strength. When $t = 0$, the sample is the clean image ($\cos(0)=1, \sin(0)=0$). When $t = \pi/2$, the sample is pure noise ($\cos(\pi/2)=0, \sin(\pi/2)=1$).

Why this form: the trigonometric coefficients ensure that $\cos^2(t) + \sin^2(t) = 1$, maintaining a constant total variance throughout the diffusion process. This is mathematically cleaner than the alternative Flow Matching parameterization $\boldsymbol{x}_t = (1-t)\boldsymbol{x}_0 + t\boldsymbol{z}$ because it preserves the variance normalization without requiring explicit rescaling, which simplifies the derivation of the consistency objective.

The TrigFlow optimal estimator. For a TrigFlow model $\boldsymbol{F}_{\theta}$, the optimal (conditional expectation) prediction is:

$\boldsymbol{F}^*(\boldsymbol{x}_{t,\texttt{Trig}}, t_{\texttt{Trig}}, \boldsymbol{y}) = \mathbb{E}\left[\cos(t_{\texttt{Trig}})\boldsymbol{z} - \sin(t_{\texttt{Trig}})\boldsymbol{x}_0 \mid \boldsymbol{x}_{t_{\texttt{Trig}}}, \boldsymbol{y}\right]$

where $\boldsymbol{F}^*$ is the optimal estimator, $\boldsymbol{y}$ is the text conditioning, and the expectation is over the posterior distribution of clean images and noise given the noisy observation.

What this computes: given a noisy image at time t, the model predicts a specific linear combination of the noise and the clean image—$\cos(t)$ times the noise minus $\sin(t)$ times the clean image. This is analogous to the "score" in score-based models, representing the direction that moves the sample toward the clean image.

Why this form: this specific linear combination is the one that appears naturally when taking the time derivative of the interpolation $\boldsymbol{x}_t = \cos(t)\boldsymbol{x}_0 + \sin(t)\boldsymbol{z}$, which is $-\sin(t)\boldsymbol{x}_0 + \cos(t)\boldsymbol{z}$. The model learns to predict this derivative, which is the optimal denoising direction under the TrigFlow parameterization.

Consistency distillation objective. Rather than training from scratch (Consistency Training), the paper uses Consistency Distillation (CD). The key difference is in the target: instead of using the raw noise as supervision (which is a high-variance, unbiased estimator), CD uses the teacher's classifier-free guided velocity as the target. Specifically:

1. For a given noisy image at timestep t, the teacher model produces a classifier-free guided output $\boldsymbol{v}_{\text{teacher}} = \boldsymbol{v}_{\text{cond}} + w(\boldsymbol{v}_{\text{cond}} - \boldsymbol{v}_{\text{uncond}})$, where w is the guidance scale.
2. This velocity is converted to the TrigFlow estimator $\boldsymbol{F}_{\text{teacher}}$ using the interconversion formulas (Equations 22–23 in the appendix).
3. The student model $\boldsymbol{F}_{\theta}$ is trained to match this teacher-derived target.

The loss function (implicit in the sCM formulation; derived in Appendix A.2) can be written as:

$\mathcal{L}_{\text{sCM}} = \mathbb{E}_{t,\boldsymbol{x}_t}\left[\boldsymbol{f}_{\theta}^{\top}(\boldsymbol{x}_t, t) \frac{\mathrm{d}\boldsymbol{f}_{\theta^{-}}(\boldsymbol{x}_t, t)}{\mathrm{d}t}\right]$

where $\boldsymbol{f}_{\theta}(\boldsymbol{x}_t, t) = \boldsymbol{x}_t - t\boldsymbol{F}_{\theta}(\boldsymbol{x}_t, t)$ is the Flow Matching parameterization of the denoising function (satisfying $\boldsymbol{f}_{\theta}(\boldsymbol{x}_0, 0) = \boldsymbol{x}_0$), and $\theta^{-}$ denotes parameters with stopped gradients (typically an EMA of the online network).

What this computes: the inner product between the model's predicted clean image $\boldsymbol{f}_{\theta}(\boldsymbol{x}_t, t)$ and the time derivative of the target network's prediction $\frac{\mathrm{d}}{\mathrm{d}t}\boldsymbol{f}_{\theta^{-}}(\boldsymbol{x}_t, t)$. This derivative term measures how the target's prediction changes as we move along the diffusion trajectory. Minimizing this inner product (the loss is typically negative, so "minimizing" means making it more negative) encourages the model's prediction to align with the direction of change in the target's prediction.

Why this form: this is a tangent-based consistency objective. For a perfectly consistent model, $\boldsymbol{f}_{\theta}(\boldsymbol{x}_t, t)$ would be constant along trajectories (equal to $\boldsymbol{x}_0$), meaning its time derivative would be zero. The loss penalizes deviations from this ideal: if the model's prediction $\boldsymbol{f}_{\theta}$ is non-zero, and the target's prediction is changing with time (non-zero derivative), the loss is non-zero. The stopped-gradient target $\theta^{-}$ provides a stable regression target that doesn't chase its own tail during optimization.

Training configuration. The sCM distillation is performed at 512×512 resolution with a total batch size of 128 and a learning rate of $1 \times 10^{-6}$. Training runs for 3,000 iterations, because "we observed no further improvement in the GenEval overall score beyond this point" (Section 4.1). The short training duration (compared to MeanFlow's 25,000 iterations) is a notable practical advantage.

Why teacher guidance instead of raw noise. The paper's choice to use the teacher's classifier-free guided output as the target, rather than the unbiased but noisy $\boldsymbol{z} - \boldsymbol{x}_0$ target used in standard consistency training, is critical for T2I. Classifier-free guidance is essential for text-to-image generation—without it, images lack prompt adherence. By incorporating the guided teacher output directly into the distillation target, the student learns to internalize the guidance effect, so it can produce guided-quality outputs in a single forward pass without needing to run two separate forward passes (conditional and unconditional) at inference time. This is a substantial practical advantage: at NFE=1, a standard CFG approach would require 2 NFEs (one conditional, one unconditional), but the sCM student produces the guided output in 1 NFE.

The student's inference procedure. At inference time, the trained sCM student can be sampled using standard TrigFlow-based solvers. The paper evaluates at NFE = 1, 2, and 4, with the student producing structurally coherent images even at NFE=1 (visible in Figure 1: recognizable giraffes and buses). The key enabling property is that the consistency training has taught the model to map from any noise level to the clean image in one step, so coarse discretization (large time steps) doesn't cause the trajectory to diverge from the data manifold.

---

3.4.3 MeanFlow Distillation: Average Velocity Learning with Jacobian-Vector Products

The MeanFlow pipeline takes a fundamentally different approach: instead of learning to jump directly to the clean image, it learns the average velocity between two timesteps, which straightens the trajectory so that coarse discretization yields accurate integration.

The core concept: average velocity instead of instantaneous velocity. Standard Flow Matching models learn $\boldsymbol{v}(\boldsymbol{x}_t, t)$, the instantaneous velocity at a point. When you discretize the ODE $\frac{\mathrm{d}\boldsymbol{x}_t}{\mathrm{d}t} = \boldsymbol{v}(\boldsymbol{x}_t, t)$ with large step sizes, errors accumulate because the velocity changes between the start and end of each step. MeanFlow directly learns the average velocity $\bar{\boldsymbol{v}}(\boldsymbol{x}_t, t, r)$ between times t and r (r < t), which by definition satisfies:

$\boldsymbol{x}_r = \boldsymbol{x}_t - (t - r) \cdot \bar{\boldsymbol{v}}(\boldsymbol{x}_t, t, r)$

What this computes: if you move from time t to time r using the average velocity $\bar{\boldsymbol{v}}$, you arrive exactly at $\boldsymbol{x}_r$. The factor $(t-r)$ is the time interval, so $\bar{\boldsymbol{v}} \cdot (t-r)$ is the total displacement.

Why this form: standard instantaneous velocity discretization uses the approximation $\boldsymbol{x}_r \approx \boldsymbol{x}_t - (t-r) \cdot \boldsymbol{v}(\boldsymbol{x}_t, t)$, which is a first-order Euler step. The error is proportional to $(t-r)^2$ times the velocity derivative. By learning the true average velocity, MeanFlow eliminates this first-order discretization error entirely, meaning you can take much larger steps (fewer NFEs) without accuracy loss—provided the learned average velocity is accurate.

The MeanFlow target construction. The average velocity cannot be directly observed from a single noisy sample—you would need to simulate the entire trajectory from t to r to compute it. MeanFlow circumvents this using a Taylor expansion and Jacobian-vector products (JVPs).

The target $\boldsymbol{u}_{\text{tgt}}$ (denoted as the average velocity to be learned) is constructed as:

$\boldsymbol{u}_{\text{tgt}} = \boldsymbol{v}_t - (t - r) \frac{\mathrm{d}\boldsymbol{u}}{\mathrm{d}t}$

where $\boldsymbol{v}_t$ is the instantaneous velocity at time t (provided by the teacher during distillation, or $\boldsymbol{e} - \boldsymbol{x}$ during from-scratch training), and $\frac{\mathrm{d}\boldsymbol{u}}{\mathrm{d}t}$ is the total time derivative of the model's own predicted average velocity.

What this computes: this is a first-order Taylor expansion of the average velocity. The true average velocity between t and r is $\frac{1}{t-r}\int_r^t \boldsymbol{v}(\boldsymbol{x}_s, s) \mathrm{d}s$. Approximating the velocity as linear in time over the interval [r, t], the integral equals $\boldsymbol{v}_t - \frac{t-r}{2}\frac{\mathrm{d}\boldsymbol{v}}{\mathrm{d}t}$. The MeanFlow target drops the factor of 1/2 because the model predicts $\boldsymbol{u}$ directly rather than $\boldsymbol{v}$. The key insight is that $\frac{\mathrm{d}\boldsymbol{u}}{\mathrm{d}t}$ can be computed using automatic differentiation without simulating the trajectory.

Why this form: it converts an integral over a trajectory (which would require simulation) into a point evaluation plus a derivative correction (which requires only a single forward pass plus a JVP). The derivative $\frac{\mathrm{d}\boldsymbol{u}}{\mathrm{d}t}$ captures the curvature of the trajectory—how much the velocity changes over the interval. If the trajectory is perfectly straight (constant velocity), this term is zero and the average velocity equals the instantaneous velocity. If the trajectory curves, this term corrects for the curvature.

The Jacobian-vector product computation. The total derivative $\frac{\mathrm{d}\boldsymbol{u}}{\mathrm{d}t}$ is computed as:

$\frac{\mathrm{d}\boldsymbol{u}}{\mathrm{d}t} = \frac{\partial\boldsymbol{u}}{\partial\boldsymbol{z}} \cdot \boldsymbol{v} + \frac{\partial\boldsymbol{u}}{\partial t}$

where $\frac{\partial\boldsymbol{u}}{\partial\boldsymbol{z}}$ is the Jacobian of the model's output with respect to its input, $\boldsymbol{v}$ is the velocity at the current point, and $\frac{\partial\boldsymbol{u}}{\partial t}$ is the partial derivative with respect to time.

What this computes: the chain rule decomposition of the total derivative. The first term $\frac{\partial\boldsymbol{u}}{\partial\boldsymbol{z}} \cdot \boldsymbol{v}$ accounts for how the model's prediction changes because the input $\boldsymbol{z}$ is moving along the flow at velocity $\boldsymbol{v}$. The second term $\frac{\partial\boldsymbol{u}}{\partial t}$ accounts for how the prediction changes because time itself is advancing. Together, they capture the full rate of change of $\boldsymbol{u}$ along the flow trajectory.

Why this form: the Jacobian-vector product $\frac{\partial\boldsymbol{u}}{\partial\boldsymbol{z}} \cdot \boldsymbol{v}$ can be computed efficiently using forward-mode automatic differentiation (a single JVP operation) without materializing the full Jacobian matrix, which would be $d \times d$ for a d-dimensional latent space. This makes the computation practical even for high-dimensional latent representations.

MeanFlow loss function and the fourth-power innovation. The MeanFlow training loss is:

$\mathcal{L}_{\text{MeanFlow}}(\theta) = \mathbb{E}_{t,\boldsymbol{z}_t}\left[\left\|\boldsymbol{u}_{\theta}(\boldsymbol{z}_t, r, t) - \operatorname{sg}(\boldsymbol{u}_{\text{tgt}})\right\|_2^{2\gamma}\right]$

where $\boldsymbol{u}_{\theta}$ is the model's predicted average velocity, $\operatorname{sg}(\cdot)$ denotes stop-gradient (the target is not differentiated through), and $\gamma$ controls the loss exponent.

What this computes: the L2 error between the model's prediction and the constructed target, raised to the power $2\gamma$ (so the norm itself is squared, then raised to $\gamma$). When $\gamma = 1$, this is the standard squared L2 loss. When $\gamma = 2$, this is the fourth power of the L2 norm.

Why $\gamma = 2$ (fourth-power loss): The original MeanFlow paper recommends $p = 1$ or $p = 0.5$ (where p corresponds to $\gamma$ in this notation) as generally optimal. However, Section 4.2.2 reports that for T2I distillation, $\gamma = 2$ yields substantially better results, boosting GenEval from 44.04% to 48.65%. The paper attributes this to "a distinct gradient behavior beneficial for our distillation objective." The mechanism: a fourth-power loss penalizes large errors much more heavily than small errors compared to a squared loss, which focuses the optimization on the worst-offending samples—those where the student's prediction deviates substantially from the teacher's trajectory. This is particularly important in distillation because the teacher's guidance near the data manifold (low noise levels) is already very accurate; the large errors occur primarily at high noise levels where the trajectory is more curved, and the fourth power forces the student to prioritize correcting these.

Dual-timestep architectural modification. Unlike standard FLUX.1-lite, which conditions on a single timestep t via sinusoidal embeddings followed by an MLP projection used for AdaLN (Adaptive Layer Normalization) modulation, the MeanFlow student must condition on both the current time t and the reference time r. The architecture is modified as follows:

1. The original time embedding branch (sinusoidal embedding of t + MLP projection) is retained.
2. A clone of this entire branch is created, initialized with the same weights as the original.
3. The cloned branch processes the time differential $t - r$ (not r directly).
4. The outputs of the two branches are summed before being passed to the AdaLN modulation layers.

What this computes: the model receives information about both "where we are" (t) and "how far we're jumping" (t−r) through separate, specialized embedding pathways, then combines them additively before modulating the network activations.

Why this design: (1) Processing t−r rather than r encodes the interval length as the key variable, which is invariant to absolute time position—a jump of size 0.1 should behave similarly whether it's from t=0.9 to r=0.8 or from t=0.3 to r=0.2. (2) Summing the embeddings (rather than concatenating) is weight-efficient and preserves the dimensionality of the original modulation pathway, minimizing architectural disruption. (3) Initializing the cloned branch with the original weights ensures that at the start of training, the (t−r) branch produces meaningful (if not yet specialized) embeddings rather than random ones.

Distillation vs. from-scratch: why the teacher matters. Algorithm 1 (MeanFlow Training) uses $\boldsymbol{v} = \boldsymbol{e} - \boldsymbol{x}$ as the base velocity, where $\boldsymbol{e}$ is random noise and $\boldsymbol{x}$ is a clean image. This is an unbiased but high-variance estimator of the true vector field—for any given noisy sample, the actual noise $\boldsymbol{e}$ could be very different from the conditional expectation $\mathbb{E}[\boldsymbol{e} \mid \boldsymbol{z}]$.

Algorithm 2 (MeanFlow Distillation) replaces this with $\boldsymbol{v}_{\text{teacher}} = g_n(\boldsymbol{z}, t)$, where $g_n$ is the pretrained flow-matching teacher. Since the teacher has converged to $g_n(\boldsymbol{z}, t) \approx \mathbb{E}[\boldsymbol{v} \mid \boldsymbol{z}]$, this provides a denoised, deterministic target. The paper explains: "the teacher has already converged to the conditional expectation of the vector field... Consequently, $\boldsymbol{v}_{\text{teacher}}$ represents a denoised, deterministic approximation of the optimal transport path."

What this means operationally: the MeanFlow objective becomes focused purely on trajectory curvature correction rather than simultaneously learning the data distribution. The teacher provides the "where to go" signal, and the student's JVP-based correction handles "how to get there smoothly." This division of labor is why distillation outperforms from-scratch training empirically.

Improved CFG for MeanFlow. Standard classifier-free guidance computes $\boldsymbol{v}_{\text{cfg}} = \boldsymbol{v}_{\text{cond}} + w(\boldsymbol{v}_{\text{cond}} - \boldsymbol{v}_{\text{uncond}})$, where w is the guidance scale. The Improved CFG variant (from Appendix B.2 of the original MeanFlow paper) introduces a mixing scale $\kappa$ that blends conditional and unconditional predictions in the regression target itself:

$\boldsymbol{v}_{\text{target}} = \boldsymbol{v}_{\text{cond}} + \kappa \cdot (\boldsymbol{v}_{\text{cond}} - \boldsymbol{v}_{\text{uncond}})$

What this computes: a blended velocity target that incorporates the CFG direction during training, with $\kappa$ controlling the strength of the guidance signal in the distillation target.

Why this matters: the vanilla MeanFlow target ($\kappa = 0$) provides no guidance signal during training, meaning the student must learn to generate guided outputs purely from the trajectory straightening objective. The Improved CFG variant explicitly incorporates guidance into the target, making the distillation objective more directly aligned with how the model will be used at inference time (with CFG). The empirical result: GenEval improves from 48.65% to 51.41% with this modification.

Training configuration and convergence behavior. MeanFlow distillation uses the same batch size (128) and resolution (512×512) as sCM, but is trained for substantially longer: 25,000 iterations vs. 3,000 for sCM. The paper notes that "extending the training duration yielded continuous gains in the GenEval score" (Section 4.1), suggesting that MeanFlow's optimization landscape is less sharply peaked than sCM's—the model continues to benefit from additional training well past the point where sCM plateaus.

Why MeanFlow collapses at NFE=1. The dramatic failure at NFE=1 (0.78% on GenEval, producing pure noise as shown in Figure 1) is not explained in detail by the paper, but can be understood from the method's mechanism. MeanFlow learns the average velocity over intervals, but the JVP-based Taylor approximation is a first-order correction. When the step size (t−r) is very large—as in NFE=1 where a single step must traverse the entire diffusion process—the first-order Taylor expansion may be a poor approximation of the true average velocity, especially for the highly curved trajectories near the data manifold. The model produces a velocity estimate that, when integrated over such a large step, lands far from the clean image. sCM, by contrast, learns to directly map to the clean image, so a single large step is within its explicit training objective.

Why MeanFlow excels at NFE=4. At 4 steps, the per-step interval is small enough that the first-order Taylor correction is accurate, and the trajectory straightening benefit kicks in: the learned average velocities produce more accurate integration than sCM's consistency mapping alone, resulting in superior detail (the giraffe's fur texture, the bus reflections in Figure 1) and higher DPG-Bench scores (80.03 vs. 77.85 for sCM at NFE=4, Table 2).

---

3.4.4 Theoretical Unification: How the Methods Relate

Section 3 of the paper establishes formal mathematical relationships between the methods studied. These connections are not merely theoretical exercises—they provide the conceptual framework for understanding what design choices actually distinguish the methods.

Flow Matching is a special case of MeanFlow (when r = t). The general MeanFlow objective (Algorithm 3) samples two times t and r, constructs a noisy sample $\boldsymbol{z} = (1-t)\boldsymbol{x} + t\boldsymbol{e}$, computes a JVP to get $\frac{\mathrm{d}\boldsymbol{u}}{\mathrm{d}t}$, and constructs the target $\boldsymbol{u}_{\text{tgt}} = \boldsymbol{v} - (t-r)\frac{\mathrm{d}\boldsymbol{u}}{\mathrm{d}t}$. When $r = t$, the correction term $(t-r)\frac{\mathrm{d}\boldsymbol{u}}{\mathrm{d}t}$ vanishes to zero, and the target simplifies to $\boldsymbol{u}_{\text{tgt}} = \boldsymbol{v} = \boldsymbol{e} - \boldsymbol{x}$. This is exactly the standard Flow Matching objective (Algorithm 4): learn the instantaneous velocity $\boldsymbol{v}$. The pseudocode comparison in the paper illustrates this cleanly—Algorithm 3 reduces to Algorithm 4 by setting $r = t$ and removing the JVP computation.

What this means operationally: MeanFlow generalizes Flow Matching by adding the trajectory curvature correction. If you set r very close to t, you're essentially doing Flow Matching with a small extra term. If you set r far from t, you're learning a fundamentally different quantity (average velocity over a long interval). This unified view explains why MeanFlow can be used as both a training objective (setting r far from t to learn few-step capability from scratch) and a distillation objective (using the teacher's velocity as $\boldsymbol{v}$ in the target).

TrigFlow and Flow Matching are interconvertible without retraining. The appendix (Section A.1) derives the bidirectional conversion formulas. A noisy sample in TrigFlow is $\boldsymbol{x}_{t,\texttt{Trig}} = \cos(t_{\texttt{Trig}})\boldsymbol{x}_0 + \sin(t_{\texttt{Trig}})\boldsymbol{z}$. The corresponding Flow Matching time that preserves the signal-to-noise ratio is:

$t_{\texttt{FM}} = \frac{\sin(t_{\texttt{Trig}})}{\cos(t_{\texttt{Trig}}) + \sin(t_{\texttt{Trig}})}$

What this computes: given a TrigFlow time, what Flow Matching time produces the same ratio of signal power to noise power? This ensures the noisy samples are statistically equivalent under both parameterizations.

Why this matters practically: a model trained under the TrigFlow formulation (like the sCM student) can be sampled using Flow Matching solvers, and vice versa, without any retraining. The TrigFlow model's output $\boldsymbol{F}_{\theta}$ is converted to a Flow Matching velocity via:

$\widehat{\boldsymbol{v}}_{\theta}(\boldsymbol{x}_{t,\texttt{FM}}, t_{\texttt{FM}}, \boldsymbol{y}) = \frac{1}{\sqrt{t_{\texttt{FM}}^2 + (1-t_{\texttt{FM}})^2}} \boldsymbol{F}_{\theta}(\boldsymbol{x}_{t,\texttt{Trig}}, t_{\texttt{Trig}}, \boldsymbol{y}) - \frac{1-2t_{\texttt{FM}}}{t_{\texttt{FM}}^2 + (1-t_{\texttt{FM}})^2} \boldsymbol{x}_{t,\texttt{FM}}$

This interoperability means practitioners can mix and match model training paradigms and sampling algorithms—e.g., train with sCM's stable TrigFlow objective but sample with a Flow Matching solver that might have better discretization properties.

sCM and MeanFlow gradients are structurally equivalent (up to EMA and time weighting). Section 3.3 (with formal derivation in Appendix A.2) compares the parameter gradients under the Flow Matching parameterization $\boldsymbol{f}_{\theta}(\boldsymbol{x}_t, t) = \boldsymbol{x}_t - t\boldsymbol{F}_{\theta}(\boldsymbol{x}_t, t)$. The sCM gradient is:

$\nabla_{\theta}\mathcal{L}_{\text{sCM}} = \mathbb{E}_{t,\boldsymbol{x}_t}\left[-\left\langle t\nabla_{\theta}\boldsymbol{F}_{\theta}(\boldsymbol{x}_t, t), \boldsymbol{v}_t - \boldsymbol{F}_{\theta^{-}}(\boldsymbol{x}_t, t) - t\frac{\mathrm{d}\boldsymbol{F}_{\theta^{-}}}{\mathrm{d}t}\right\rangle\right]$

The MeanFlow gradient (with r = 0) is:

$\nabla_{\theta}\mathcal{L}_{\text{MeanFlow}} = \mathbb{E}_{t,\boldsymbol{x}_t}\left[-\left\langle \nabla_{\theta}\boldsymbol{F}_{\theta}(\boldsymbol{x}_t, t), \boldsymbol{v}_t - \boldsymbol{F}_{\theta}(\boldsymbol{x}_t, t) - t\frac{\mathrm{d}\boldsymbol{F}_{\theta^{-}}}{\mathrm{d}t}\right\rangle\right]$

What differs: (1) The sCM gradient has an extra factor of t multiplying $\nabla_{\theta}\boldsymbol{F}_{\theta}$, giving more weight to later timesteps (closer to pure noise). (2) The sCM gradient uses $\boldsymbol{F}_{\theta^{-}}$ (EMA target network) in the error term, while the MeanFlow gradient uses $\boldsymbol{F}_{\theta}$ (online network). Since $\theta^{-}$ has stopped gradients, the numerical values of $\boldsymbol{F}_{\theta}$ and $\boldsymbol{F}_{\theta^{-}}$ are identical at any given moment—the EMA just changes which parameters the stop-gradient is applied to. The paper concludes that "MeanFlow is not a distinct method, but a specific, simplified variant of sCM that dispenses with the EMA-based target stabilization."

What this means operationally: the key practical difference between sCM and MeanFlow is (a) whether an EMA target network is used (sCM: yes, MeanFlow: no) and (b) the time weighting (sCM: weighted by t, MeanFlow: uniform). The EMA target provides training stability by giving a slowly-moving regression target; removing it makes the training more "self-referential" and potentially less stable but also more responsive. The empirical results bear this out: sCM trains stably for 3,000 iterations before plateauing; MeanFlow requires 25,000 iterations for convergence.

IMM reduces to discrete-time Consistency Models under specific choices. Section 3.4 shows that when IMM is configured with (a) single-particle estimates ($\boldsymbol{x}_t = \boldsymbol{x}_t'$ and $\boldsymbol{x}_r = \boldsymbol{x}_r'$), (b) negative squared Euclidean distance as the kernel ($k(x,y) = -\|x-y\|^2$), and (c) target time $s = 0$, the IMM loss simplifies to:

$\mathcal{L}_{\text{IMM}}(\theta) = \mathbb{E}_{\boldsymbol{x}_t, \boldsymbol{x}_r, t}\left[w(t)\left[\|\boldsymbol{g}_{\theta}(\boldsymbol{x}_t, t) - \boldsymbol{g}_{\theta^{-}}(\boldsymbol{x}_r, r)\|^2\right]\right]$

where $\boldsymbol{g}_{\theta}$ is the EDM-parameterized denoising function.

What this computes: the squared L2 distance between the model's clean-image prediction from a noisy sample at time t and the target network's clean-image prediction from a (different) noisy sample at time r. This is exactly the discrete-time consistency model loss.

Why this connection matters: it shows that IMM's distributional perspective (matching distributions via MMD) and CM's pointwise perspective (matching individual sample predictions) converge to the same objective when using single samples and a squared-distance kernel. The distributional formulation is more general (it can use multiple particles and different kernels), but the practical instantiation that works for few-step generation is the one that reduces to consistency training. This explains why the paper focuses on sCM rather than IMM for the T2I experiments: IMM's additional generality (multiple particles, MMD kernel choices) doesn't provide advantages beyond what consistency training already offers, while adding computational complexity.

---

3.4.5 Evaluation Protocol and Codebase Infrastructure

Benchmarks. The paper evaluates on two standard text-to-image benchmarks:

• GenEval (Table 1): measures compositional text-to-image generation across multiple axes including single object, two objects, counting, colors, position, and attribute binding. The Overall score aggregates these sub-scores.
• DPG-Bench (Table 2): evaluates dense prompt generation, measuring alignment of global structure, entities, attributes, and relations between the prompt and generated image.

Sampling configuration. The teacher model (FLUX.1-lite) is evaluated at NFE=28 with its standard sampler. The students are evaluated at NFE = 1, 2, and 4 using samplers appropriate to their formulation (TrigFlow-based for sCM, flow-based for MeanFlow).

Training infrastructure. Section 4.1 specifies: 32 Nvidia H20 GPUs, proprietary high-quality text-to-image dataset (ensuring consistent and fair comparison across experiments—same data for both methods).

Codebase design (Section 5). The implementation builds on Hugging Face Diffusers with two primary training pipelines. Key technical features:

• DeepSpeed ZeRO for distributed training across 32 GPUs, enabling 8B-parameter model training.
• bfloat16 mixed precision to reduce memory usage while maintaining training stability.
• Gradient checkpointing to trade compute for memory, enabling larger batch sizes.
• On-the-fly encoding via pretrained AutoencoderKL, operating in a 16-channel latent space with 8× downsampling—images are encoded to latents before entering the diffusion process, and decoded back to pixels only for evaluation/visualization.
• Teacher-student paradigm built on modified FLUX.1-lite MMDiT architecture with the timestep and dual-timestep modifications described above.

The open-source release includes pretrained student models alongside the training code, enabling direct reproduction and comparison.

4. Key Insights and Innovations

Innovation 1: Trajectory Straightening and Consistency Mapping Are Complementary, Step-Count-Dependent Strategies—Not Competitors

The paper's most intellectually distinctive contribution is reframing what appeared to be competing methods (sCM and MeanFlow) as complementary strategies optimized for different regimes of the step-count vs. quality tradeoff. Prior to this work, the few-step generation literature implicitly treated trajectory-based distillation methods as alternatives—you picked one and hoped it worked well across all step counts. The papers proposing sCM (lu2025simp) and MeanFlow (geng2025mean) each argued for their method's advantages in isolation, on ImageNet, without characterizing where the other approach might be preferable.

This paper's head-to-head comparison reveals a mechanism-level explanation for why no single method dominates: sCM learns a direct mapping from noise to clean image, which makes it robust at NFE=1–2 (the extreme few-step regime) because the model's objective is explicitly to handle large jumps. MeanFlow learns to straighten trajectories by modeling average velocity, which means its per-step integration is more accurate when the number of steps is sufficient for the first-order Taylor expansion to hold—hence its superior fidelity at NFE=4. The GenEval results crystallize this: sCM achieves 52.81% at NFE=2 (matching the teacher's 53.58%), while MeanFlow collapses to 0.78% at NFE=1 but reaches 80.03 on DPG-Bench at NFE=4 (surpassing sCM's 77.85). These are not noise-level differences—they represent qualitatively different operating regimes where one method fundamentally fails and the other succeeds.

What makes this a conceptual advance rather than just a benchmark comparison: the paper identifies the mechanism behind the tradeoff. sCM's consistency objective penalizes deviation from the clean image at every point along the trajectory, which forces the model to produce coherent structure even from pure noise in one step, but doesn't specifically optimize for trajectory smoothness—so additional steps refine details but don't fundamentally restructure the image. MeanFlow's average-velocity objective optimizes for trajectory straightness, which makes integration more accurate as steps increase, but when the step size exceeds the radius of convergence of the first-order Taylor approximation (as in NFE=1), the correction term becomes actively harmful. This is not a "method A beats method B" finding—it's a diagnostic principle: trajectory straightness and pointwise consistency are distinct geometric properties of the learned mapping, and different step-count regimes stress different properties.

The practical implication is a design rule for practitioners: if your latency budget allows only 1–2 NFEs, use sCM; if you can afford 4, use MeanFlow. This is a decision framework rather than a method recommendation, and it's grounded in the geometry of the learning objectives rather than accidental empirical outcomes.

---

Innovation 2: Distillation as a Teacher-Provided Variance Reduction Mechanism, Not Just Knowledge Transfer

The paper makes a subtle but important reframing of what distillation does in the context of trajectory-based few-step generation. The standard narrative around distillation is that it transfers knowledge from a large, expensive teacher to a smaller, faster student—a form of model compression. But in this work, the student models have the same architecture and parameter count (8B) as the teacher—there is no compression. So what is distillation actually providing?

The answer, articulated most clearly in the MeanFlow adaptation (Section 4.2.2), is variance reduction in the training target. The from-scratch MeanFlow objective (Algorithm 1) uses v = e − x as the base velocity, where e is a randomly sampled noise vector. This is an unbiased estimator of the conditional expectation E[v | z], but it is extremely high-variance—for any particular noisy image, the specific noise that was added to create it could be very different from the average noise that would be added across all possible clean images consistent with that noisy observation. The distillation variant (Algorithm 2) replaces this with v_teacher = g_n(z, t), where g_n is the pretrained teacher. Since the teacher has converged to approximate the conditional expectation, its output is a denoised, deterministic estimate.

The paper explicitly frames this as: "the MeanFlow objective u_tgt = v_teacher − (t−r) du/dt focuses purely on rectifying the curvature of the trajectory via the Jacobian correction term, rather than learning the data distribution from scratch." This is a division of labor argument: the teacher handles "what direction to move" (the data distribution), while the student's JVP-based correction handles "how to move smoothly" (the trajectory geometry). This reframing matters because it explains why distillation outperforms from-scratch training for MeanFlow even when the student has the same capacity as the teacher—it's not about compressing knowledge into a smaller model, but about decomposing the learning problem into a solved component (density estimation, provided by the teacher) and an unsolved component (trajectory straightening, learned by the student).

This insight generalizes beyond MeanFlow. The sCM pipeline also uses teacher guidance: the student is trained to match the teacher's classifier-free guided velocity rather than the raw noise. Again, this is variance reduction—the raw noise is a high-variance target, while the teacher's CFG output is a low-variance estimate of the desired guided denoising direction. By incorporating the guidance signal directly into the distillation target, the student learns to produce guided outputs in a single forward pass, eliminating the need for the typical two-pass (conditional + unconditional) CFG computation at inference time.

Why this is distinctive: prior distillation work in diffusion models (LADD, DMD) focused on matching output distributions—the student learns to produce samples that fool a discriminator or minimize a distributional divergence. This paper's trajectory methods use distillation differently: to provide a low-variance supervision signal for intermediate trajectory points, enabling the student to learn the dynamics of generation rather than just its endpoint. This is a more granular use of the teacher that exploits its convergence to the conditional expectation, which is a property that distribution-matching approaches don't leverage.

---

Innovation 3: The Theoretical Unification Reveals That EMA Target Networks Are the Critical Distinguishing Design Choice

Section 3.3 establishes that under the Flow Matching parameterization, the gradients of sCM and MeanFlow are structurally identical except for two factors: (1) an extra time-weighting t in sCM's gradient, and (2) the use of an EMA target network F_{θ−} in sCM versus the online network F_θ in MeanFlow. The paper interprets MeanFlow as "a specific, simplified variant of sCM that dispenses with the EMA-based target stabilization."

This is a diagnostic contribution that cuts through the surface-level differences between the methods (TrigFlow vs. Flow Matching, inner product loss vs. L2 loss, consistency mapping vs. average velocity) to identify what actually matters for training behavior. The paper's theoretical analysis shows that the TrigFlow–FM parameterizations are interconvertible without retraining (Section 3.2), so the choice of parameterization is not a fundamental distinction. The loss function form (inner product vs. squared L2) is shown to produce equivalent gradients up to a time-weighting factor (Appendix A.2). What remains as the genuine fork in the design space is whether to use an EMA target network.

Why this is significant beyond this paper: the EMA target network is a technique borrowed from reinforcement learning and self-supervised representation learning (e.g., BYOL, DQN) where it serves to stabilize bootstrapped training by providing a slowly-moving regression target. Its presence in sCM and absence in MeanFlow explains the empirical convergence differences: sCM plateaus at 3,000 iterations, suggesting the EMA provides rapid stabilization but also limits the model's ability to continue improving (since the target lags behind the online network); MeanFlow continues improving through 25,000 iterations, suggesting that the self-referential training dynamic (where the model chases its own predictions) enables ongoing refinement but requires much longer training to converge.

This framing converts what appeared to be independent methods into points in a design space parameterized primarily by the EMA choice (and secondarily by loss weighting). It implies that future work should not treat these as separate algorithms to choose between, but as design dimensions to tune: one could imagine an interpolated method that starts with a strong EMA for stability and gradually decays it to enable the refinement benefits of self-referential training. The paper does not explore this, but the theoretical unification provides the conceptual scaffolding for doing so.

---

Innovation 4: Timestep Normalization as a Critical but Overlooked Practical Bottleneck for Continuous-Time Methods on Discrete-Time Pretrained Models

The paper identifies and solves a failure mode that, while not glamorous, represents an important practical insight: continuous-time consistency training objectives are numerically unstable when applied to models pretrained with discrete-time conventions (timesteps in [0, 1000]). The gradient norm grows continuously during training and eventually causes collapse.

What makes this a contribution rather than just engineering: this is not an obvious problem from the method papers. The sCM paper (lu2025simp) trains from scratch on ImageNet, where the timestep range can be chosen arbitrarily from the start. The MeanFlow paper similarly controls the timestep parameterization during training. But when adapting these methods to a pretrained T2I model like FLUX.1-lite—which uses the 0–1000 convention inherited from DDPM and embedded in its pretrained weights—the mismatch between the discrete-time pretraining and the continuous-time distillation objective creates a concrete instability. The paper demonstrates this empirically and provides a validated fix: teacher-student distillation at proportionally scaled timesteps to create a [0,1]-normalized student, verified to match the original teacher's GenEval performance (Table 1, first two lines).

Why this matters for the broader field: most state-of-the-art diffusion models available to practitioners are pretrained with discrete-time conventions (Stable Diffusion, FLUX, DALL-E, Imagen). The trajectory-based distillation methods that show the most promise for few-step generation were developed and validated in from-scratch or class-conditional settings where timestep parameterization is a free design choice. This paper's finding—that directly applying these methods to off-the-shelf T2I models causes training collapse—is a transferability barrier that any practitioner attempting similar adaptations will encounter. The solution (preliminary distillation with timestep rescaling) is a general recipe that applies beyond sCM and MeanFlow to any continuous-time method applied to discrete-time pretrained backbones. The paper's validation that this rescaling preserves generation quality is the key evidence that this is a safe transformation, not a compromise.

This insight is analogous to the batch normalization re-calibration issue that arose when adapting ImageNet-pretrained classifiers to new domains—a practical bottleneck that, once identified and solved, unblocks an entire line of research. The paper doesn't frame it in these grand terms, but the pattern is the same: a methodological innovation (continuous-time distillation) cannot be deployed on existing assets without solving a previously invisible infrastructure problem (timestep range mismatch).

---

Innovation 5: The IMM–CM Reduction Shows That Distributional Consistency Objectives Collapse to Pointwise Consistency Under Practical Constraints

Section 3.4 provides a concise mathematical demonstration that Inductive Moment Matching—which is motivated by distribution-level consistency enforced through Maximum Mean Discrepancy—reduces to the standard discrete-time consistency model loss when instantiated with single-particle estimates, squared Euclidean distance kernels, and target time s = 0. The derivation is straightforward: the four-term MMD estimator collapses to a two-term squared L2 distance between the model's prediction and the EMA target's prediction.

What makes this a conceptual contribution: this result clarifies that the distributional perspective of IMM, while mathematically elegant and more general in principle, does not introduce a mechanistically distinct learning signal under the practical configurations that work for few-step generation. The additional generality—multiple particles, arbitrary kernels—adds computational complexity but, based on the theoretical analysis, converges to the same objective as consistency models when stripped to the settings that produce usable few-step models. This explains (retrospectively) why the paper focuses experimental effort on sCM rather than IMM for T2I adaptation: if the practical instantiation reduces to CM, there is no reason to pay the computational cost of the more general framework.

Why this matters beyond this paper: the result is a negative finding with positive implications—it tells researchers that if they're interested in few-step generation specifically, the distribution-matching framing of IMM doesn't buy them anything that consistency training doesn't already provide, and they should invest effort in making consistency training work better rather than exploring the richer but practically equivalent IMM formulation. This is a form of methodological pruning—identifying which dimensions of a design space are actually expressive and which are redundantly parameterized. The paper doesn't conduct IMM experiments on T2I, but the theoretical reduction provides a principled justification for that scope limitation rather than leaving it as an unexplained omission.

5. Experimental Analysis

Evaluation Methodology

• Dataset. All experiments use a proprietary high-quality text-to-image dataset. The paper states it "cannot be publicly released" but "ensures a consistent and fair comparison across all experiments" (Section 4.1). No further details on dataset size, composition, or source are provided, which limits independent reproducibility.
• Base model(s). The teacher model is FLUX.1-lite, an 8-billion-parameter text-to-image diffusion model. The paper argues this is a strong, representative contemporary T2I model. A timestep-rescaled version of this model (accepting timesteps in [0,1] rather than [0,1000]) is created via preliminary distillation and serves as the base for both sCM and MeanFlow student training. The students share the same architecture and parameter count (8B) as the teacher—there is no model compression.
• Metrics. Two standard text-to-image benchmarks are used. GenEval (Table 1) measures compositional text-to-image generation across multiple axes (single object, two objects, counting, colors, position, attribute binding) and reports an Overall score aggregating these sub-scores. DPG-Bench (Table 2) evaluates dense prompt generation, measuring alignment of global structure, entities, attributes, and relations between the prompt and generated image. The paper does not report FID, CLIP score, or other common T2I metrics, which limits comparability with broader literature.
• Baselines. The primary baseline is the original FLUX.1-lite teacher evaluated at NFE=28 (its standard multi-step sampling configuration). The timestep-rescaled teacher serves as an additional baseline to validate that the [0,1] normalization preserves generation quality. There is no comparison against distribution distillation methods (DMD, LADD) or against simpler baselines like progressive distillation or direct preference optimization, which would contextualize the trajectory methods' performance relative to alternative few-step approaches. The paper also does not compare against the from-scratch training variants of sCM or MeanFlow, despite having the theoretical framework to do so.
• Generation budget / compute accounting. The unit of comparison is NFE (Number of Function Evaluations)—one forward pass through the 8B-parameter model. The teacher uses NFE=28. Students are evaluated at NFE = 1, 2, and 4. All student models have identical parameter counts to the teacher, so per-NFE computational cost is equal across methods. Training compute: 32 Nvidia H20 GPUs are used for all experiments. sCM trains for 3,000 iterations; MeanFlow trains for 25,000 iterations. The paper does not report total training FLOPs or wall-clock time, making it difficult to assess the relative training cost of the two methods beyond the iteration count (MeanFlow requires ~8.3× more iterations than sCM).
• Cross-validation / statistical protocol. None reported. The paper does not mention multiple training runs, error bars, or statistical significance testing. Results appear to be from single training runs. This is a significant limitation: at the reported performance levels, differences of 1–2 percentage points on GenEval (e.g., between rescaled teacher at 53.58% and sCM NFE=2 at 52.81%) could potentially fall within run-to-run variance, but without multiple seeds or confidence intervals this cannot be assessed. The small training iteration counts (3,000 for sCM) make the results potentially sensitive to initialization and data ordering.

---

Main Quantitative Results

Timestep Rescaling Validation

The paper first validates that the timestep normalization procedure does not degrade the teacher model. Table 1 reports:

• Original FLUX.1-lite (NFE=28): GenEval Overall = 53.58%
• Rescaled teacher (NFE=28): GenEval Overall = 53.58% (the paper states the performance is "nearly identical," though the exact sub-score breakdowns are not provided in the excerpt)

This is the foundational result that enables both distillation pipelines—if the rescaling had compromised quality, all subsequent comparisons would be against a degraded baseline.

sCM Distillation Results

Table 1 reports sCM's performance across NFE counts on GenEval:

The headline finding: sCM at NFE=2 achieves 52.81%, effectively matching the teacher's 53.58% at NFE=28—a 14× reduction in inference compute with only a 0.77 percentage point drop. At NFE=1, sCM retains 43.28%, which the paper characterizes as "structurally coherent images even at a single step" (Figure 1 caption).

Table 2 reports DPG-Bench results:

sCM demonstrates "robust performance at NFE=1 and NFE=2" (Table 1 caption) and "superior stability and alignment at lower step counts (NFE ≤ 2)" (Table 2 caption). The paper does not provide the exact DPG-Bench values at NFE=1 and NFE=2 in the extracted text, which limits precise quantitative comparison.

MeanFlow Distillation Results

Table 1 reports MeanFlow's performance on GenEval:

The collapse at NFE=1 is dramatic: 0.78% is essentially chance-level performance on a compositional benchmark. The paper visually corroborates this in Figure 1: the MeanFlow NFE=1 column shows pure gray noise outputs. At NFE=2, "the model begins to form semantic content... but significant artifacts and noise remain" (Section 4.3). At NFE=4, MeanFlow "produces images with exceptional sharpness and correct semantics, often surpassing sCM in fine-grained detail."

Table 2 quantifies the NFE=4 advantage: MeanFlow achieves 80.03 on DPG-Bench versus sCM's 77.85, and the paper states it "nearly matches the teacher" (the teacher's DPG-Bench score is not provided in the extracted text for direct comparison). The qualitative evidence in Figure 1 supports the quantitative findings: MeanFlow at NFE=4 shows superior fur texture on the giraffe and better reflection detail on the buses compared to sCM at the same step count.

Hyperparameter Impact on MeanFlow Performance

Section 4.2.2 reports two hyperparameter ablations that substantially affect MeanFlow's GenEval score:

• Loss exponent γ: Using the original MeanFlow paper's recommendation (γ = 1 or γ = 0.5, corresponding to squared L2 or L1 loss) yields a GenEval score of 44.04%. Switching to γ = 2 (effectively a fourth-power loss) boosts performance to 48.65%—a 4.61 percentage point improvement.
• Improved CFG: Adding the classifier-free guidance mixing scale κ to the distillation target further improves GenEval from 48.65% to 51.41%—an additional 2.76 percentage point gain.

The paper does not report these ablations in a standalone table; the numbers appear inline in Section 4.2.2. The combined effect (44.04% → 51.41%) represents a 7.37 percentage point improvement from two hyperparameter changes, underscoring the sensitivity of trajectory distillation methods to training configuration in the T2I domain.

Training Convergence Comparison

Section 4.1 reports the training duration findings:

• sCM: Trained for 3,000 iterations. The paper states "we observed no further improvement in the GenEval overall score beyond this point."
• MeanFlow: Trained for 25,000 iterations. The paper states "extending the training duration yielded continuous gains in the GenEval score."

This represents an ~8.3× difference in training iterations, with MeanFlow requiring substantially more compute to converge.

---

Ablation Studies and Robustness Checks

Timestep rescaling validation: The rescaled teacher achieves GenEval scores "nearly identical" to the original FLUX.1-lite (Table 1, first two lines). This confirms that the [0,1] normalization is a safe transformation that preserves generation quality, validating the foundation for both distillation pipelines.

Teacher-guided velocity targets vs. standard consistency training (sCM): The paper uses the teacher's classifier-free guided output as the sCM target rather than training from scratch with raw noise supervision. While not presented as a formal ablation, the architectural choice is motivated by the need to internalize CFG into single-pass inference. The paper does not report a comparison against from-scratch sCM (consistency training without distillation), which would quantify the benefit of the teacher guidance.

Distillation vs. from-scratch training (MeanFlow): Section 4.2.2 states that MeanFlow is "significantly more effective as a distillation technique" than as a from-scratch training objective, attributing this to the teacher providing a "denoised, deterministic approximation of the optimal transport path" versus the "highly stochastic" raw noise target. No quantitative comparison between Algorithms 1 and 2 is reported, so the magnitude of the distillation benefit remains unquantified.

Loss exponent γ: As noted above, γ = 2 substantially outperforms the original paper's recommendation of γ = 1 or γ = 0.5 (44.04% → 48.65% on GenEval). The paper attributes this to "distinct gradient behavior," with the fourth-power loss penalizing large errors more heavily.

Improved CFG mixing scale κ: Adding κ to the MeanFlow target improves GenEval from 48.65% to 51.41%. The paper does not report the specific κ value used or sweep multiple κ values, so the sensitivity to this hyperparameter is unknown.

Training duration: sCM plateaus at 3,000 iterations; MeanFlow continues improving through 25,000 iterations. This suggests qualitatively different optimization landscapes for the two objectives. The paper does not report whether MeanFlow eventually plateaus beyond 25,000 iterations or whether sCM's plateau is robust to learning rate schedule changes.

Missing ablations: Several comparisons that would strengthen the paper are absent. There is no ablation of the EMA decay rate in sCM (which Section 3.3 identifies as the critical distinguishing design choice from MeanFlow). There is no comparison at NFE=8 or NFE=16 to determine where MeanFlow's advantage saturates. There is no ablation of the dual-timestep architecture design (e.g., processing r directly vs. processing t−r, or concatenation vs. summation of time embeddings). There is no comparison against distribution distillation methods (LADD, DMD) on the same teacher and dataset, which would contextualize trajectory methods against the current state-of-the-art for T2I few-step generation. There is no comparison against simpler baselines like progressive distillation. The resolution at which sCM is trained (512×512) differs from the timestep rescaling resolution (1024×1024), but the effect of this resolution mismatch is not ablated.

---

Critical Assessment

Claim 1: sCM maintains robust performance at NFE=1/2, matching the teacher at NFE=2. Partially supported. The GenEval Overall score at NFE=2 (52.81%) is indeed close to the teacher's NFE=28 score (53.58%), supporting the claim of teacher-matching quality with 14× fewer NFEs. However, the claim of NFE=1 robustness is supported only by GenEval (43.28%) and qualitative evidence (Figure 1)—the DPG-Bench NFE=1 score is not reported, so structural/organizational text-image alignment at NFE=1 is unquantified. The 43.28% GenEval score, while "respectable," represents a substantial ~10 percentage point drop from NFE=2, which some practitioners might not consider "robust." The absence of error bars or multiple training runs means we cannot assess whether 52.81% vs. 53.58% is within run-to-run variance—it could be a genuine small degradation or statistical noise.

Claim 2: MeanFlow requires NFE=4 to match teacher quality, and collapses at NFE=1. Strongly supported. The 0.78% GenEval at NFE=1 is unambiguous evidence of collapse, and Figure 1's visual evidence (pure noise outputs) corroborates this. The DPG-Bench score of 80.03 at NFE=4 surpassing sCM's 77.85 supports the claim of superior fidelity at 4 steps. However, the teacher's DPG-Bench score is not provided in the extracted text, so "matches the teacher" at NFE=4 cannot be verified quantitatively from the available data.

Claim 3: The methods establish a tradeoff—sCM for NFE ≤ 2, MeanFlow for NFE=4. Supported at the endpoints tested, but the claim extrapolates from three data points (NFE=1, 2, 4). We don't know what happens at NFE=3, where the methods might cross over. We don't know if MeanFlow at NFE=8 would substantially outperform sCM at NFE=8, or if the advantage saturates. The claim is a useful rule of thumb based on the available data, but the paper's step-count sweep is sparse.

Genuine weaknesses in experimental design:

• Single model family, single teacher. All results are on FLUX.1-lite, an 8B MMDiT architecture. The paper's findings about training stability (timestep rescaling necessity, γ=2 loss, EMA impact on convergence speed) may be specific to this architecture or parameter count. Without replication on other T2I backbones (e.g., Stable Diffusion 3, DALL-E, PixArt-α), the generalizability of the practical guidelines is unknown. The paper frames itself as a "practical guide," but the guidance is validated on exactly one model.
• No comparison against distribution distillation methods. The paper's introduction positions distribution distillation (DMD, LADD) as the established approach that has "been successfully applied to text-to-image synthesis tasks with significant results" (Section 1). The absence of a DMD or LADD baseline on the same teacher and dataset is a significant gap—we cannot assess whether trajectory methods offer advantages over the simpler distribution-matching paradigm for T2I. SD3-Turbo (using LADD) and Qwen-Image-Lightning (using DMD) exist as potential comparison points but are not benchmarked.
• Proprietary dataset prevents reproduction. All experiments use a dataset that "cannot be publicly released." This means the quantitative results in Tables 1 and 2 cannot be independently reproduced, even with the open-source code. The paper argues this "ensures a consistent and fair comparison across experiments," which it does—internally—but external validation is impossible. For a paper positioning itself as a practical guide with open-source implementation, this undermines the central value proposition.
• No statistical rigor. Single training runs without error bars or multiple seeds make it impossible to assess whether differences between methods are statistically significant or within run-to-run noise. At the GenEval performance levels reported (~50%), run-to-run variance of 1–3 percentage points would not be unusual in generative model training, which means the sCM NFE=2 vs. teacher comparison (52.81% vs. 53.58%) could be a statistical tie or a genuine small degradation—we cannot tell.
• Training cost asymmetry is not discussed as a practical tradeoff. MeanFlow requires 25,000 iterations vs. sCM's 3,000—an ~8.3× difference—yet the paper does not present this as part of the method comparison. A practitioner choosing between methods needs to weigh this training cost against the inference-time quality advantages. If the MeanFlow student takes 8× longer to train for a ~3 DPG-Bench point advantage at NFE=4, that tradeoff should be explicit.
• Resolution mismatch in training pipeline. The timestep rescaling distillation is done at 1024×1024, but sCM training is done at 512×512. The paper does not discuss whether this resolution discrepancy affects the quality of the consistency learning or whether training sCM at 1024×1024 (matching the rescaling resolution) would change results. For a method that learns to map from noise to clean image in one step, the resolution at which this mapping is learned could substantially impact fidelity.
• The 3,000-iteration sCM plateau finding is stated but not demonstrated. The paper says "we observed no further improvement in the GenEval overall score beyond this point" but does not show a training curve or report intermediate checkpoints. This makes it impossible to assess whether the plateau is genuine or an artifact of the specific learning rate schedule.

Missing experiments that would strengthen the paper:

• NFE=3 and NFE=8 evaluation to characterize the crossover point between methods and the saturation behavior.
• From-scratch training variants of both sCM and MeanFlow to quantify the distillation benefit.
• Distribution distillation baselines (LADD, DMD) on the same FLUX.1-lite teacher and dataset.
• Multiple training seeds with confidence intervals.
• Standard image quality metrics (FID, CLIP score) alongside GenEval and DPG-Bench for comparability with broader literature.
• Ablation of EMA decay rate in sCM to test whether the EMA/no-EMA distinction (identified theoretically in Section 3.3 as the critical design choice) actually drives the observed convergence and performance differences.
• Scaling the training data size to assess whether the methods are data-hungry or data-efficient—particularly important given the proprietary dataset constraint.
• Evaluation on an open-source dataset (e.g., COCO captions, PartiPrompts) to enable community benchmarking even if the training data remains proprietary.

6. Limitations and Trade-offs

6.1 Proprietary Training Dataset Prevents Independent Reproduction

The constraint. All experiments in this paper use "a proprietary high-quality text-to-image dataset" that "cannot be publicly released" (Section 4.1). The paper provides no details about the dataset's size, composition, prompt diversity, image resolution distribution, or curation methodology. While the authors argue this "ensures a consistent and fair comparison across all experiments," it fundamentally prevents any external party from reproducing the results—even with the open-source code and pretrained models provided—or from assessing whether the reported performance generalizes to different data distributions.

The consequence. A practitioner cannot determine whether the specific hyperparameter findings (γ = 2 for MeanFlow loss, Improved CFG with mixing scale κ, 3,000-iteration plateau for sCM, 25,000-iteration convergence for MeanFlow) are properties of the distillation methods themselves or artifacts of the particular training data. If the proprietary dataset differs systematically from publicly available T2I datasets (e.g., in prompt complexity, aesthetic quality, or concept coverage), the reported GenEval and DPG-Bench scores may not replicate even when using the released code and models on different evaluation prompts. The paper's framing as a "practical guide" is undercut by the inability to verify that the guidance works beyond the authors' specific training setup. For organizations evaluating whether to adopt sCM or MeanFlow distillation for their own T2I deployment, the absence of data transparency means they must replicate the full experimental pipeline on their own data to determine whether the claimed tradeoffs (sCM for NFE ≤ 2, MeanFlow for NFE=4) hold.

Evidence in the paper. The limitation is stated explicitly in Section 4.1 but with no compensating analysis—no experiments on a public dataset, no sensitivity analysis varying dataset composition, and no characterization of how dataset properties (size, prompt distribution, aesthetic filtering) affect distillation outcomes. The GenEval and DPG-Bench results (Tables 1 and 2) are validated only on the standard benchmark evaluation prompts, not on training data characteristics.

Mitigation status. The paper acknowledges the limitation but provides no mitigation beyond the open-source code and pretrained student models. Users could evaluate the released models on their own data, but cannot retrain to verify the training recipes. The paper does not suggest future work on dataset-independent training protocols or sensitivity analyses that would make the practical guidance more transferable.

---

6.2 No Comparison Against Distribution Distillation Baselines on the Same Teacher

The constraint. The paper's introduction explicitly positions distribution distillation methods (DMD/DMDv2 and LADD) as an established paradigm that has "been successfully applied to text-to-image synthesis tasks with significant results" (Section 1), citing SD3-Turbo and FLUX.1 Kontext as examples using LADD, and Qwen-Image-Lightning using DMD. Despite this, the experimental evaluation in Section 4 compares only sCM and MeanFlow against the multi-step teacher. There is no LADD or DMD baseline trained and evaluated on the same FLUX.1-lite teacher with the same proprietary dataset.

The consequence. The paper cannot substantiate its implicit claim that trajectory-based distillation offers advantages over distribution-based distillation for T2I. The entire comparative analysis—the tradeoff between sCM and MeanFlow, the step-count recommendations, the hyperparameter guidelines—exists in a vacuum relative to the methods that practitioners are most likely already using or considering. A practitioner reading this paper cannot determine whether sCM at NFE=2 (52.81% GenEval) is competitive with what LADD or DMD would achieve on the same teacher at the same NFE budget, nor whether the NFE=4 MeanFlow advantage (80.03 DPG-Bench) represents a meaningful improvement over distribution distillation alternatives. The paper's claim to be a "practical guide" is weakened when it does not benchmark against the most practically relevant alternative approaches.

Evidence in the paper. The absence is acknowledged only implicitly—the paper states that trajectory-based methods' "performance, adaptability, and potential advantages in the complex, open-domain task of text-to-image synthesis remain unclear" (Section 1), which motivates the study. But by not including distribution distillation baselines, the study clarifies trajectory methods' behavior while leaving their relative advantage unquantified. The experimental sections (4.1–4.3) contain no mention of attempting or comparing against LADD, DMD, or progressive distillation.

Mitigation status. The paper does not address this gap. It provides no justification for excluding distribution distillation baselines (e.g., computational constraints, architectural incompatibility with the FLUX.1-lite codebase) and does not list this as a direction for future work. The theoretical framework in Section 3 unifies trajectory methods but offers no equivalent analysis for distribution distillation, leaving the relationship between these paradigms unexplored.

---

6.3 Single Model Architecture Validates Generalizability Claims for Only One Teacher

The constraint. All experiments use a single teacher model: FLUX.1-lite, an 8-billion-parameter MMDiT (Multi-Modal Diffusion Transformer) architecture. The paper positions its findings as a "practical guide" and "solid foundation for deploying fast, high-fidelity, and resource-efficient diffusion generators in real-world T2I applications" (Abstract)—phrasing that implies generalizable guidance. However, the specific practical findings—timestep normalization necessity, γ = 2 loss exponent superiority, dual-timestep architectural modifications for MeanFlow, 3,000-iteration sCM plateau, Improved CFG benefits—are validated on exactly one model family.

The consequence. It is unknown which of these findings are architectural invariants versus artifacts of FLUX.1-lite's specific design choices. The timestep rescaling instability (gradient norm growth leading to collapse at [0,1000] range) may be specific to how FLUX.1-lite's AdaLN modulation layers interact with the timestep embedding scale. A UNet-based architecture (e.g., Stable Diffusion 3) or a different transformer variant might not exhibit this problem at all, or might require a different normalization range. Similarly, the optimal γ for MeanFlow may depend on the teacher's trajectory curvature properties, which vary with architecture and pretraining recipe. For a practitioner using a non-FLUX backbone, the paper's specific numerical recommendations (batch size 128, learning rate 1×10⁻⁶, 3,000 vs. 25,000 iterations) are unvalidated extrapolations. The paper's guidance on when to prefer sCM vs. MeanFlow—derived entirely from FLUX.1-lite results—may invert for a teacher whose trajectories have different curvature characteristics.

Evidence in the paper. The authors state they "believe this model is representative of the capabilities of many contemporary LLMs" (Section 4, paraphrased context), but provide no evidence for this claim. The paper contains no experiments on alternative T2I architectures (e.g., Stable Diffusion 3, PixArt-α, DALL-E), no sensitivity analysis varying architectural components of the teacher, and no discussion of which findings are expected to transfer and which are likely architecture-specific. All quantitative results in Tables 1 and 2 and all qualitative results in Figure 1 are from FLUX.1-lite students.

Mitigation status. The limitation is not explicitly acknowledged in the paper. The abstract's framing as establishing "a solid foundation" and providing "practical guidelines" implies broad applicability that the experimental scope does not support. The open-source codebase is tied to the FLUX.1-lite MMDiT architecture and would require non-trivial modification to support alternative backbones.

---

6.4 MeanFlow's JVP-Based Target Is Fundamentally Unreliable at Large Step Sizes, Creating a Hard Lower Bound on NFE

The constraint. The MeanFlow objective constructs the average-velocity target using a first-order Taylor expansion: u_tgt = v_teacher − (t−r) · du/dt. The Jacobian-vector product term du/dt captures trajectory curvature as a linear correction. This approximation is accurate when the step size (t−r) is small relative to the trajectory's radius of curvature, but becomes increasingly inaccurate as the step size grows. For NFE=1, where a single step must traverse the entire noise-to-image trajectory, (t−r) is maximal, and the first-order approximation can be severely mismatched to the true average velocity.

The consequence. This creates an architectural lower bound on MeanFlow's usable NFE—not an empirical observation that might improve with better training, but a mathematical limitation of the objective itself. The paper's results demonstrate this concretely: GenEval collapses to 0.78% at NFE=1, and Figure 1 shows pure noise outputs. The paper's qualitative analysis confirms NFE=2 still shows "significant artifacts and noise remain" (Section 4.3). This means MeanFlow is structurally incapable of the 1-step generation that sCM achieves (43.28% GenEval, structurally coherent images). For latency-critical applications where even 2 NFEs are too expensive (e.g., real-time AR at 30+ FPS, on-device generation), MeanFlow is simply not an option regardless of how much training compute is invested.

Evidence in the paper. The collapse is documented quantitatively (0.78% GenEval at NFE=1, Table 1) and qualitatively (Figure 1, pure gray noise outputs). The paper notes that "performance collapses at NFE=1 and NFE=2" (Section 4.3). However, the paper does not explicitly attribute this to the Taylor approximation's breakdown or analyze the relationship between step size and target accuracy—the explanation is my inference from the method's mathematical structure, supported by the empirical result. The paper does not provide an ablation studying how the JVP correction term's accuracy degrades with step size or whether higher-order corrections could extend the usable NFE range downward.

Mitigation status. The paper does not address this limitation as a fundamental property of the method. It presents the NFE-dependent performance as an empirical tradeoff ("sCM is the optimal choice for... NFE ≤ 2, while MeanFlow is preferable for... NFE=4") without analyzing whether the NFE=1 failure is a fixable implementation issue or an inherent mathematical constraint. No modifications to the MeanFlow objective (e.g., higher-order Taylor expansions, learned correction terms, or hybrid objectives that fall back to consistency-like behavior at large step sizes) are proposed or discussed. The paper does not suggest this as an area for future work.

---

6.5 Training Cost Asymmetry Is Not Factored Into the Method Comparison

The constraint. sCM distillation converges in 3,000 iterations, after which "no further improvement in the GenEval overall score" is observed (Section 4.1). MeanFlow distillation requires 25,000 iterations, with "continuous gains" throughout—an ~8.3× difference in training duration. Both use the same hardware (32 Nvidia H20 GPUs), same batch size (128), same resolution (512×512), and identical student model size (8B parameters). The paper reports these figures but does not incorporate training cost into the comparative analysis or the practical recommendations.

The consequence. A practitioner choosing between methods faces a resource allocation decision that the paper's analysis does not support. MeanFlow's advantages at NFE=4 (80.03 vs. 77.85 DPG-Bench, ~2.2 point improvement; superior fine-grained detail in Figure 1) come at the cost of ~8.3× more GPU-hours. The paper provides no framework for evaluating whether this training investment is worthwhile: is the NFE=4 quality advantage large enough to justify the training cost? Could additional sCM training iterations (beyond the reported plateau) close the gap? Would sCM trained for 25,000 iterations with a modified learning rate schedule match MeanFlow's NFE=4 performance? The absence of training cost accounting means the paper's central practical recommendation—"sCM for NFE ≤ 2, MeanFlow for NFE=4"—ignores a first-order economic consideration.

Evidence in the paper. Section 4.1 explicitly states both iteration counts and the convergence characteristics. The paper does not report total training FLOPs, wall-clock time, or GPU-hour estimates. It does not provide training curves showing GenEval vs. iteration for either method. It does not ablate whether the sCM plateau is robust to learning rate schedule changes (which could reveal whether additional training with a different schedule would improve sCM). The paper does not compare the methods at matched training compute (e.g., sCM at 25,000 iterations vs. MeanFlow at 3,000 iterations, which would invert the resource comparison).

Mitigation status. The paper does not address training cost as a dimension of the method comparison. The iteration counts are reported as factual details without interpretation or integration into the practical guidance. Future work on reducing MeanFlow's training cost or on understanding sCM's plateau behavior is not suggested.

---

6.6 No Statistical Validation of Results from Single Training Runs

The constraint. All quantitative results in Tables 1 and 2 appear to come from single training runs. The paper reports no multiple seeds, no confidence intervals, no standard deviations, and no statistical significance tests. The evaluation benchmarks (GenEval and DPG-Bench) use fixed evaluation sets, and the paper does not report uncertainty estimates.

The consequence. The central empirical claims cannot be assessed for statistical reliability. The paper's headline finding—sCM at NFE=2 achieving 52.81% GenEval vs. the teacher's 53.58%, characterized as "effectively matching"—represents a 0.77 percentage point difference. In generative model training with 8B-parameter models, run-to-run variance of 1–3 percentage points on compositional benchmarks is plausible due to random seed effects, data ordering, and hardware-level nondeterminism. Without multiple runs, we cannot determine whether this 0.77-point gap is a genuine small degradation, statistical noise, or even an artifact that could reverse sign in a different run. Similarly, MeanFlow's hyperparameter sensitivity results (44.04% → 48.65% → 51.41% GenEval from γ and κ changes) could be partially confounded with seed variance—a different random seed at γ=1 might produce 46%, making the γ=2 advantage appear smaller. The paper's practical guidance (which method to use at which NFE) is built on point estimates whose stability is unknown.

Evidence in the paper. The methodology section (4.1) describes the training configuration but does not mention multiple runs, seed control, or statistical protocols. The results section (4.3) reports single accuracy values without error indications. The convergence findings ("no further improvement" for sCM at 3,000 iterations, "continuous gains" for MeanFlow at 25,000 iterations) are stated without training curves that would allow readers to assess noise levels in the GenEval metric over the course of training.

Mitigation status. The limitation is not acknowledged. The paper does not mention statistical validation as a consideration, does not suggest that future work should include multiple training runs, and does not provide the kind of error analysis that would allow practitioners to calibrate their confidence in the reported numbers. Given the paper's positioning as a "practical guide" with concrete recommendations, the absence of uncertainty quantification undermines the reliability of those recommendations. A practitioner following the paper's advice to use sCM at NFE=2 might, after retraining on their own data, find performance 2–3 points lower than reported due to seed variance alone, without any methodological error on their part.

7. Implications and Future Directions

How This Work Changes the Landscape

This paper reshapes our understanding of trajectory-based distillation for text-to-image generation by providing the first controlled empirical characterization of how two leading methods behave when adapted from class-conditional ImageNet to open-ended text-to-image generation. Before this work, the landscape was fragmented: sCM and MeanFlow had each demonstrated strong results in their respective papers, but on incompatible benchmarks with different base models, making it impossible to know which to choose, when, or why. This paper provides that map.

The most substantive conceptual shift is the reframing of trajectory-based distillation methods from competing alternatives to complementary tools optimized for different step-count regimes. Prior work treated methods as monolithic: you picked one and hoped it worked across all settings. This paper demonstrates that the choice is not "sCM versus MeanFlow" but rather a diagnostic question about your latency budget. The mechanism-level explanation—sCM learns pointwise consistency (direct noise-to-clean mapping, robust at large step sizes) while MeanFlow learns trajectory straightness (average velocity, accurate integration when steps are small enough for the Taylor approximation to hold)—converts what appeared to be contradictory findings into a coherent picture. This is analogous to how the compute-optimal test-time scaling paper (Snell et al., 2024) showed that different inference strategies are optimal for different prompt difficulties, resolving the apparent contradiction between papers that found self-correction works and papers that found it fails. In both cases, the contribution is not a new algorithm but a framework for understanding when existing algorithms succeed and fail.

The paper also performs a valuable methodological pruning of the design space. Section 3's theoretical analysis shows that several apparent differences between methods are superficial: TrigFlow and Flow Matching are interconvertible without retraining (Section 3.2), IMM reduces to discrete-time consistency models under practical configurations (Section 3.4), and sCM and MeanFlow gradients differ primarily in the use of an EMA target network and time weighting (Section 3.3). This analysis identifies which design choices actually matter (EMA targets, loss weighting) and which are merely notational or parametric variations (TrigFlow vs. FM parameterization, inner product vs. L2 loss form). For researchers designing new few-step methods, this is a significant contribution: it eliminates several dimensions of the design space as inexpressive and focuses attention on the dimensions that drive empirical differences.

The failure-mode characterization of MeanFlow at NFE=1 (0.78% GenEval, pure noise outputs in Figure 1) is a negative result with diagnostic value. It demonstrates that trajectory straightening alone—without pointwise consistency—cannot handle the extreme few-step regime, establishing a hard boundary condition on the method's applicability. This finding is likely to generalize: any method that relies on local trajectory approximations (Taylor expansions, learned corrections with finite radius of convergence) will face a minimum step-count threshold below which the approximation breaks. This shifts the theoretical framing of few-step generation from "how do we make the trajectory straighter?" to "how do we maintain global coherence at step sizes beyond the radius of convergence of local approximations?" The paper doesn't answer this question, but it frames it clearly for the first time in the T2I context.

The practical engineering contributions—timestep rescaling to prevent training collapse, architectural modifications for dual-time conditioning, the empirical superiority of fourth-power loss and Improved CFG for MeanFlow—lower the barrier to entry for practitioners. These are not glamorous findings, but they are the kind of concrete knowledge that determines whether a method works in practice or remains a theoretical curiosity. Before this paper, a practitioner attempting to apply sCM or MeanFlow to FLUX would likely encounter the gradient norm collapse from the [0,1000] timestep range and waste substantial compute before diagnosing the issue. The paper's validation that [0,1] rescaling preserves quality (Table 1, first two lines) provides a safe, general-purpose transformation that unblocks continuous-time methods on any pretrained discrete-time backbone.

Follow-Up Research This Work Enables

Extending MeanFlow's usable NFE range downward through higher-order corrections. The paper establishes that MeanFlow collapses at NFE=1 because the first-order Taylor approximation to the average velocity becomes inaccurate at large step sizes. A natural follow-up would extend the JVP-based target to use higher-order Taylor expansions: the second-order correction term involves the Hessian-vector product d²u/dt², which can also be computed via automatic differentiation using nested JVPs or forward-over-forward mode. The key experiment: train MeanFlow with a second-order target (JVP + HVP correction) and measure whether NFE=2 performance approaches sCM's. If a second-order correction extends the usable range to NFE=2 while preserving NFE=4 quality, the practical recommendation shifts from "use sCM for NFE ≤ 2" to "use MeanFlow for NFE ≥ 2." The negative result—higher-order corrections don't help because the Taylor series diverges at large step sizes—would be equally informative, establishing that the limitation is fundamental rather than merely a matter of approximation order.

EMA decay rate ablation in sCM to validate the Section 3.3 theoretical analysis. The paper's gradient comparison (Appendix A.2) identifies the EMA target network as the critical distinguishing design choice between sCM and MeanFlow, with the theoretically interesting implication that MeanFlow is "a specific, simplified variant of sCM that dispenses with the EMA-based target stabilization." An experiment that sweeps the EMA decay rate in sCM from 0 (no EMA, equivalent to MeanFlow's self-referential dynamic) to 0.9999 (near-static target) would directly test this hypothesis. The prediction: EMA=0 should show training instability or slower convergence (matching MeanFlow's requirement for 25K iterations), while a moderate EMA (e.g., 0.999) provides rapid convergence (3K iterations as reported) but potentially limits asymptotic performance. An intermediate result—a decaying EMA schedule that starts high for stability and decays to zero for refinement—would constitute a new method that combines the benefits of both approaches. The GenEval-vs-iterations training curves at each EMA setting would provide the first empirical characterization of the EMA/no-EMA fork in the design space.

Distribution distillation baselines on the same FLUX.1-lite teacher. The paper's most striking omission is the absence of LADD or DMD baselines. A high-priority follow-up would implement both distribution distillation methods on the identical FLUX.1-lite teacher and proprietary dataset used in this paper, then evaluate at NFE=1, 2, 4 on GenEval and DPG-Bench. The specific questions: (1) Does LADD's adversarial training match or exceed sCM's NFE=1 quality (43.28% GenEval) on the same teacher? (2) Does DMD's distribution matching at NFE=4 approach MeanFlow's 80.03 DPG-Bench? (3) Are there step-count tradeoffs within distribution distillation analogous to the sCM-vs-MeanFlow tradeoff (e.g., GAN-based methods excelling at NFE=1 but saturating, while regression-based methods scaling better to NFE=4)? This experiment would transform the paper's contribution from "sCM and MeanFlow behave as follows" to "here is the complete step-count vs. quality landscape across all major few-step paradigms on a common T2I teacher."

Cross-architecture replication on Stable Diffusion 3 or PixArt-α. The paper's practical guidelines are validated only on FLUX.1-lite's MMDiT architecture. A replication study applying the identical protocol—timestep rescaling to [0,1], sCM distillation with teacher-guided velocity targets, MeanFlow distillation with dual-timestep adaptation and γ=2 loss—to a UNet-based backbone (Stable Diffusion 3) or a different transformer variant (PixArt-α) would establish which findings are architectural invariants and which are FLUX-specific. The specific predictions: the timestep rescaling instability may not occur in UNet architectures where timestep embeddings are added rather than used for AdaLN modulation; the optimal γ for MeanFlow's loss may differ across architectures depending on trajectory curvature; and the convergence iteration counts (3K for sCM, 25K for MeanFlow) may shift substantially. The result would either validate the paper's practical guidance as broadly applicable or provide the necessary caveats for practitioners using different backbones.

Dynamic step-count allocation based on prompt complexity. The paper demonstrates that sCM excels at NFE ≤ 2 while MeanFlow excels at NFE=4, but always applies the same NFE to every prompt. An adaptive system could classify incoming prompts by complexity (using a lightweight classifier or the teacher's confidence) and route simple prompts to sCM at NFE=1 (e.g., "a cat sitting on a chair") while routing complex compositional prompts to MeanFlow at NFE=4 (e.g., "a giraffe wearing a top hat standing next to a red bus while a zebra plays chess in the background"). The experiment: train a prompt classifier on GenEval sub-task categories (single object vs. two objects vs. counting vs. attribute binding), measure the accuracy-vs-compute tradeoff of adaptive routing vs. uniform NFE, and characterize whether the prompt complexity boundaries that separate sCM-favorable from MeanFlow-favorable align with GenEval's compositional axes. This extends the paper's implicit decision framework into an automated deployment system.

From-scratch IMM on T2I to test the Section 3.4 reduction empirically. The paper's theoretical analysis shows that IMM reduces to discrete-time consistency models under practical configurations, providing a principled justification for not evaluating IMM experimentally. A follow-up could test this directly: implement IMM on the FLUX.1-lite architecture for T2I with the single-particle, squared-L2-distance configuration, and compare against sCM at matched NFE. The prediction from Section 3.4 is that IMM should perform nearly identically to sCM (since both collapse to CM-like objectives), but with higher computational cost from MMD estimation. A finding of substantially different performance would falsify the reduction and suggest that the distributional perspective provides benefits not captured by the pointwise CM objective. A finding of near-identical performance (with higher cost) would validate the paper's scope limitation and provide empirical evidence for the methodological pruning argument.

Practical Applications and Downstream Use Cases

Interactive design tools with near-instant preview. A design tool (Figma-like interface for AI image generation) where users type prompts and see results in under one second can deploy sCM at NFE=2. The paper shows sCM NFE=2 achieves 52.81% GenEval—matching the teacher's 53.58% at NFE=28—which means the visual quality users experience during rapid iteration is essentially indistinguishable from the full-quality teacher, but with 14× lower latency and compute cost. When a user finalizes a design and wants maximum quality for export, the system can switch to MeanFlow at NFE=4 (80.03 DPG-Bench, superior fine-grained detail per Figure 1) with acceptable 4-step latency. This two-tier deployment—sCM for preview, MeanFlow for final render—directly instantiates the paper's central tradeoff finding.

On-device or edge deployment of T2I models. The paper's students have the same 8B parameter count as the teacher, so the primary inference-time savings come from NFE reduction, not parameter reduction. However, the NFE reduction (14× for NFE=2 sCM, 7× for NFE=4 MeanFlow) directly translates to energy savings and latency improvements on fixed hardware. On a mobile device or edge server where running an 8B model is already at the edge of feasibility, reducing per-image forward passes from 28 to 2–4 can make the difference between viable and non-viable deployment. The paper's finding that sCM maintains structural coherence at NFE=1 (43.28% GenEval, recognizable giraffes and buses in Figure 1) is particularly relevant here: even if quality degrades relative to NFE=2, the ability to produce recognizable images in a single forward pass enables use cases (AR overlays, real-time style transfer) where latency constraints are absolute.

Batch inference for synthetic data generation. Organizations generating large volumes of synthetic images for training downstream models (e.g., generating product images for e-commerce classifiers, creating training data for object detection) care about throughput and cost, not per-image latency. Here, NFE reduction directly translates to cost savings: at NFE=2, sCM produces images at ~14× the throughput of the teacher for roughly equivalent quality (52.81% vs. 53.58% GenEval), meaning a fixed GPU budget generates ~14× more training examples. If the downstream task is robust to the small quality difference (which the paper's GenEval numbers suggest is negligible for many compositional axes), this represents a direct 14× cost reduction. For tasks requiring maximum prompt adherence (where DPG-Bench matters), NFE=4 MeanFlow at 7× throughput savings with teacher-matching DPG-Bench quality (80.03) provides a more conservative but still substantial gain.

Low-latency inference for real-time game content generation. Dynamic game environments that generate textures, objects, or scene elements in response to player actions require generation latency measured in tens of milliseconds, not seconds. The paper's sCM NFE=1 result—structurally coherent images in a single model forward pass—is the only configuration among those tested that approaches this latency regime. While 43.28% GenEval is substantially below teacher quality, for game content where exact prompt adherence matters less than speed and structural coherence (e.g., generating environmental textures, item variations, background elements), this quality-speed operating point becomes viable. The paper's qualitative evidence (Figure 1, sCM NFE=1 column) shows recognizable objects with correct semantics, which may be sufficient for many game contexts. MeanFlow's NFE=1 collapse (pure noise) makes it categorically unsuitable here—this is the clearest practical decision boundary the paper establishes.