AlphaFlow: Understanding and Improving MeanFlow Models

ArXiv: 2510.20771

🎯 Pitch

MeanFlow’s training secretly suffers from a tug-of-war between flow matching and consistency losses, with 75% of compute wasted on border-case supervision just to keep the peace. AlphaFlow fixes this with a simple curriculum that anneals from flow matching to MeanFlow, cutting the border-case reliance and hitting a new state-of-the-art FID of 2.58 (1 step) on ImageNet-1K 256² using vanilla DiT backbones.

1. Executive Summary

This paper analyzes why MeanFlow—a recently proposed framework for few-step generative modeling trained from scratch—works effectively, and introduces α-Flow, a unified family of training objectives that generalizes trajectory flow matching, Shortcut Models, and MeanFlow under a single formulation. Through gradient analysis on ImageNet-1K 256×256 using DiT backbones, the authors reveal that the MeanFlow objective decomposes into two strongly negatively correlated components—trajectory flow matching and trajectory consistency—whose optimization conflict causes slow convergence, with the commonly used border-case flow matching supervision (r = t for 75% of samples) acting as a surrogate that mitigates this conflict at substantial computational overhead. By employing a curriculum strategy that smoothly anneals from trajectory flow matching to MeanFlow (scheduling a consistency step ratio α from 1 to 0), α-Flow disentangles these conflicting objectives and reduces reliance on the border-case supervision, achieving a new state-of-the-art FID of 2.58 at 1 NFE and 2.15 at 2 NFE with the largest DiT-XL/2+ model—a 15% relative improvement over MeanFlow-XL/2 at the same training budget—while establishing that the gains from the curriculum approach are most pronounced when pure flow matching pretraining precedes the gradual introduction of the consistency objective.

2. Context and Motivation

The Core Problem: Few-Step Generation from Scratch Is Still Hard

The fundamental challenge this paper addresses is the yawning performance gap between multi-step diffusion models and their few-step counterparts when both are trained from scratch. Diffusion models (Ho et al., 2020; Song & Ermon, 2019; Rombach et al., 2022) dominate image generation, with systems like Stable Diffusion 3 (Esser et al., 2024) producing photorealistic images. However, these models require an iterative sampling process—typically dozens to hundreds of neural function evaluations (NFEs)—to progressively denoise a random input into a coherent image. Each function evaluation is a full forward pass through the network, making inference computationally expensive and slow. This bottleneck has real consequences: it limits deployment on edge devices, increases energy costs in production pipelines, and makes interactive applications (real-time image editing, video generation) impractical.

The natural solution—compress the sampling process into fewer steps—has spawned two families of approaches:

Distillation-based methods (Salimans & Ho, 2022; Sauer et al., 2024; Yin et al., 2024b;a) take a pre-trained multi-step diffusion model and condense its behavior into a student model that produces comparable output in 1–4 steps. These work well because the teacher model already knows the full denoising trajectory, but they come with a catch: you must train the expensive multi-step model first, then train the distilled few-step model on top. This two-stage pipeline doubles the training cost and means the few-step model cannot exceed its teacher's quality—it can only approximate it.

From-scratch methods aim to train few-step generative models directly, without a multi-step teacher. This is where the paper's central tension lives. Consistency Models (CMs) (Song et al., 2023) were the breakthrough here, showing that a model can learn to map any point along the denoising trajectory directly to clean data by enforcing self-consistency: the model's prediction from a noisy input at timestep $t$ must match its prediction from the slightly less noisy state at $t - \Delta t$. This worked in principle, but suffered from training instability—small values of $\Delta t$ improved accuracy but caused gradient explosion, while large values stabilized training but sacrificed quality. A series of improvements followed: better discretization schedules (Geng et al., 2025b), continuous-time formulations via Jacobian-vector products (Lu & Song, 2025), and trajectory-based generalizations that allow jumps between any two timesteps rather than always jumping to $t = 0$ (Kim et al., 2024; Frans et al., 2025). Each of these chipped away at the gap, but a significant performance deficit remained—few-step models were still noticeably worse than their multi-step counterparts.

Then came MeanFlow (Geng et al., 2025a), which the paper positions as the current state-of-the-art for from-scratch few-step flow models. MeanFlow's key idea is to train the model to predict the mean velocity over an interval $[r, t]$ rather than the instantaneous velocity at a single point. This changes the training objective to:

$L_{\text{MF}}(\theta) = \mathbb{E}_{t, r, z_t} \left[ \left\| u_\theta(z_t, r, t) - v_t + (t - r) \frac{du_{\theta^-}(z_t, r, t)}{dt} \right\|_2^2 \right]$

The mean velocity formulation effectively integrates consistency training with velocity prediction, and MeanFlow achieves significantly better few-step generation quality than previous from-scratch methods—it bridges much of the gap to multi-step models. However, the paper identifies a critical knowledge gap: nobody understands why MeanFlow works so well. As the authors state in Section 1:

"Despite its practical success, there still lacks a clear understanding of why MeanFlow performs better, which hinders further improvements and the design of stronger few-step models."

This lack of understanding isn't academic nitpicking—it has direct practical consequences. If you don't know what makes MeanFlow tick, you can't systematically improve it. You're left doing hyperparameter search in the dark, hoping that small tweaks help. The paper points to a concrete example of this opacity: MeanFlow's empirically discovered practice of setting $r = t$ for 75% of training samples (what the paper calls "border-case flow matching supervision"). This is computationally wasteful—three-quarters of training samples go to an objective that isn't even the primary focus (since $r = t$ collapses the interval to zero and reduces MeanFlow to vanilla flow matching). Yet removing this practice hurts performance. Why? What role is this border-case supervision playing? Without understanding the underlying loss landscape, these questions are unanswerable.

Why This Matters: The Scaling Implications

The few-step generation problem matters beyond academic curiosity because it sits at the intersection of two major trends in generative modeling:

The scaling arms race. Modern image generation pipelines (Esser et al., 2024; Brooks et al., 2024) use enormous DiT (Peebles & Xie, 2023) architectures with hundreds of millions to billions of parameters. Training these models from scratch consumes thousands of GPU-days. If you can match multi-step quality with 1–2 NFEs instead of 50–100, you reduce inference cost by 25–50×. For a deployed system serving millions of users, that translates to enormous savings in compute, energy, and latency. Improving few-step models directly improves the efficiency of the entire deployment pipeline.

From-scratch training enables new capabilities. Distillation methods are inherently tethered to their teacher model—the few-step student cannot outperform the teacher, and the teacher must be trained first. From-scratch methods, by contrast, allocate the entire training budget to the few-step model itself. If you can train a strong few-step model from scratch, you avoid the two-stage cost and open the door to few-step models that might eventually exceed what multi-step models can achieve at comparable training FLOPs. The paper's α-Flow results—achieving 2.58 FID at 1 NFE with a vanilla DiT-XL/2+ trained from scratch—demonstrate this potential concretely.

The training efficiency puzzle. The paper's analysis reveals that MeanFlow's training dynamics are inherently conflictual: the two components of its objective (trajectory flow matching and trajectory consistency) have strongly negatively correlated gradients (cosine similarity below −0.4 throughout training, as shown in Figure 2a). This means that gradient descent is constantly pulled in opposing directions—improving one component degrades the other. The border-case $r = t$ supervision, while wasteful, partially mitigates this conflict. This suggests that previous from-scratch methods may have been bottlenecked not by model capacity or data, but by poorly structured optimization landscapes that prevent efficient convergence. If true, this is important because it shifts the research focus from architecture design to loss function design—a much cheaper axis to optimize.

Where Prior Approaches Fall Short

The paper situates MeanFlow's limitations within a broader landscape of few-step generation methods, identifying specific shortcomings that motivate α-Flow:

Consistency Models (CMs) have an inherent bias-variance tension. The discrete consistency training objective (Equation 2) minimizes the difference between the model's output at $t$ and $t - \Delta t$. As $\Delta t \to 0$, the discretization error vanishes (the continuous limit matches the true ODE trajectory), but the gradient variance explodes—small differences in the model's output at nearly identical timesteps become dominated by noise. As $\Delta t \to 1$, the gradients stabilize but the model learns a poor approximation. This forces practitioners to carefully schedule $\Delta t$ during training (Song & Dhariwal, 2024; Geng et al., 2025b), adding complexity and making the training process brittle. The continuous-time formulation (Equation 3) eliminates the $\Delta t$ parameter through Jacobian-vector products, but introduces significant computational overhead and scalability challenges in modern deep learning frameworks (Wang et al., 2025b; Peng et al., 2025).

Trajectory-based methods fix one problem but create another. Consistency Trajectory Models (CTM) (Kim et al., 2024) and Shortcut Models (Frans et al., 2025) generalize CMs by learning to jump between arbitrary pairs of timesteps $(t, r)$ rather than always jumping to $r = 0$. This enables multi-step refinement during inference—you can take a few large jumps, then finer jumps if needed. However, the training objectives for these methods have their own challenges. Shortcut Models (Equation 4) enforce consistency by requiring that a direct jump from $t$ to $r$ matches two consecutive jumps through an intermediate timestep $s$. This introduces a self-bootstrapping target (the model's own predictions are used as supervision for its current prediction), which can propagate errors and amplify instability. The paper notes that Shortcut Models only work effectively when the consistency step ratio $\alpha$ (controlling the relative position of $s$ within $[r, t]$) is relatively large—specifically $\alpha = 0.5$—which limits their flexibility.

MeanFlow works but is opaque and computationally inefficient. As discussed, MeanFlow achieves strong results but leaves several questions unanswered. Why does border-case $r = t$ supervision help? Why is 75% the sweet spot? Can we reduce this computational overhead while maintaining or improving performance? More fundamentally: is the MeanFlow objective the right loss to optimize, or is it a convenient proxy that happens to work well through a combination of gradient dynamics we don't yet understand? The paper's gradient analysis (Section 3) provides some answers, showing that the $r = t$ supervision acts as a surrogate for trajectory flow matching with reduced gradient conflict against the consistency term—but this is an empirical observation about a training hack, not a principled solution.

Flow-Anchored Consistency Models (FACM) (Peng et al., 2025) and Inductive Moment Matching (IMM) (Zhou et al., 2025) represent alternative directions but either require substantially more computation per epoch (FACM uses roughly 2× the FLOPs per epoch compared to MeanFlow, as noted in Table 1) or rely on moment matching rather than exact trajectory consistency, which trades off precision for stability. The paper positions these as competitors that outperform MeanFlow in some regimes but at higher cost or with different tradeoffs, suggesting there is still room for methods that improve performance without increasing computational overhead.

How This Paper Positions Itself

The paper's positioning can be understood along three axes:

Analytical axis: explain before improving. Rather than proposing yet another loss function or architecture, the paper first does the hard work of understanding why existing methods behave as they do. The decomposition of the MeanFlow objective (Equation 6) into trajectory flow matching ($L_{\text{TFM}}$) and trajectory consistency ($L_{\text{TCc}}$) is not just a mathematical curiosity—it's the key that unlocks the design of α-Flow. By showing that these two components are naturally antagonistic (Section 3.2, Figure 2a), the paper provides a causal explanation for MeanFlow's training dynamics: joint optimization of conflicting objectives causes slow convergence, and the border-case $r = t$ supervision partially resolves this conflict by replacing trajectory flow matching with a less-antagonistic surrogate ($L_{\text{FM}'}$). This analysis transforms MeanFlow from an empirical success story into a system whose failure modes are understood, enabling principled improvement.

Unification axis: α-Flow as a framework, not just a method. Theorem 1 is the paper's central theoretical contribution: it shows that trajectory flow matching, Shortcut Model training, MeanFlow training, discrete consistency training, and continuous consistency training are all special cases of a single α-Flow loss, with the consistency step ratio $\alpha$ as the unifying hyperparameter. At $\alpha = 1$, you get trajectory flow matching. At $\alpha = 0.5$, you get Shortcut Models (up to a scaling factor). At $\alpha \to 0$, you recover MeanFlow's gradient. At $r = 0$ with $z_0$-parameterization, you get discrete or continuous CT depending on whether $\alpha$ is a small constant or approaches zero.

This unification is powerful because it transforms the design problem from "choose which method to use" to "choose how to schedule $\alpha$ during training." The paper's key insight is that you don't have to choose—you can anneal $\alpha$ from 1 to 0 over the course of training, starting with the well-behaved trajectory flow matching objective (low variance, stable gradients, establishes a good noise-to-data mapping) and gradually transitioning to MeanFlow (higher variance but lower bias for few-step generation). This curriculum learning strategy is the natural consequence of understanding the gradient conflict: by decoupling the optimization of $L_{\text{TFM}}$ and $L_{\text{TCc}}$ temporally, you avoid the interference that plagues joint optimization.

Practical axis: better results at lower cost. The paper demonstrates that α-Flow's curriculum strategy not only improves final performance—achieving 2.95 FID vs. 3.47 for MeanFlow at 1 NFE with the same DiT-XL/2 architecture and 240 training epochs—but also reduces the need for border-case flow matching supervision. As shown in Table 2(b), α-Flow achieves its best 1-NFE performance at only 25% $r = t$ ratio, compared to 75% for MeanFlow. This directly addresses the computational inefficiency identified in the analysis: by pretraining on pure trajectory flow matching, α-Flow front-loads the optimization of $L_{\text{TFM}}$, reducing the reliance on the surrogate $L_{\text{FM}'}$ during later stages. The paper thus positions α-Flow as both a theoretical advance (understanding the loss landscape) and a practical improvement (better performance with less wasted computation).

The paper also explicitly positions itself as complementary to, rather than competing with, ongoing work on improving the stability and scalability of diffusion model training. Section 8 (Conclusion) frames α-Flow as building on the foundations laid by MeanFlow, Shortcut Models, and consistency training, and suggests that the unification perspective may enable further improvements—for instance, combining α-Flow's curriculum strategy with improved verifier architectures (though the paper doesn't use verifiers in the generation sense) or extending the framework to other generative modeling domains beyond image synthesis.

3. Technical Approach

3.1 Reader Orientation

This paper is primarily an analysis-and-improvement paper that first diagnoses why MeanFlow training suffers from slow convergence (through gradient analysis revealing conflicting objectives), then proposes α-Flow—a unified family of training objectives with a curriculum learning strategy that resolves this conflict, improving both training efficiency and final image generation quality. The system being built is a training recipe for few-step flow-based generative models; the core idea is to replace MeanFlow's joint optimization of conflicting objectives with a three-phase curriculum that first establishes a good noise-to-data mapping via trajectory flow matching, then gradually transitions to the MeanFlow objective by annealing a consistency step ratio α from 1 to 0, and finally fine-tunes purely on MeanFlow—all while significantly reducing the wasteful border-case flow matching supervision that MeanFlow required.

3.2 Big-Picture Architecture (Diagram in Words)

The α-Flow training system has four major components:

1. Base neural network ($u_\theta$): A DiT-based velocity predictor that takes a noisy latent $z_t$, a start timestep $r$, and an end timestep $t$ as input, and outputs an estimated mean velocity over the $[r, t]$ interval. This is the model being trained from scratch—there is no pre-trained teacher.

2. Loss function ($L_\alpha$): A unified objective parameterized by a consistency step ratio $\alpha \in (0, 1]$ that smoothly interpolates between trajectory flow matching ($\alpha = 1$), Shortcut Model training ($\alpha = 0.5$), and MeanFlow training ($\alpha \to 0$). The loss enforces consistency across timesteps by introducing an intermediate timestep $s = \alpha r + (1 - \alpha) t$ and requiring that the model's prediction from $t$ matches a target constructed from the ground-truth velocity and the model's own prediction from the intermediate state.

3. Curriculum scheduler: A sigmoid-based annealing function $\alpha(k)$ that maps the current training iteration $k$ to a consistency step ratio, defined by start iteration $k_s$, end iteration $k_e$, temperature $\gamma$, and clamping value $\eta$. This scheduler implements the three-phase curriculum: pure flow matching pretraining ($\alpha = 1$), gradual transition ($\alpha \in (0, 1)$), and MeanFlow fine-tuning ($\alpha \to 0$).

4. Adaptive loss weighting: A mechanism that scales the loss by $\omega = \alpha / (\|\Delta\|_2^2 + c)$ where $\|\Delta\|_2^2$ is the squared L2 error and $c = 10^{-3}$ is a small constant for numerical stability. This weighting, derived as an α-scaled version of the MeanFlow adaptive weight, prevents high-error samples from dominating gradients.

Information flows as follows: a clean image $x$ is sampled from the training set → noise $\epsilon \sim \mathcal{N}(0, I)$ is sampled → timesteps $t, r$ are sampled from a logit-normal distribution → the noisy latent $z_t = (1-t)x + t\epsilon$ is constructed → the curriculum scheduler provides the current $\alpha$ → the intermediate timestep $s = \alpha r + (1-\alpha) t$ is computed → the model predicts $u_\theta(z_t, r, t)$ → if $\alpha = 0$, a Jacobian-vector product computes the MeanFlow target; otherwise, the model's own prediction at $z_s$ (computed via a forward Euler step) is used to construct the α-Flow target → the adaptive weight is computed and applied → backpropagation updates $\theta$.

3.3 Roadmap for the Deep Dive

• First, the MeanFlow loss decomposition (Section 3.1), because understanding what α-Flow fixes requires understanding what MeanFlow actually optimizes at the gradient level—the paper reveals that MeanFlow is secretly optimizing two antagonistic objectives whose gradient conflict explains the need for border-case supervision.
• Second, the gradient conflict analysis (Section 3.2), which provides the empirical justification for why joint optimization fails and why $L_{\text{FM}'}$ helps—this is the diagnostic step that motivates the curriculum design.
• Third, the α-Flow loss definition (Section 4.1, Equation 8), which is the unified objective whose structure handles the gradient conflict through temporal decoupling rather than loss mixing.
• Fourth, the unification theorem (Theorem 1), which establishes that α-Flow is not just a new loss but a generalization that subsumes five existing methods—this validates the framework's breadth and explains how properties of each special case inform the curriculum design.
• Fifth, the three-phase curriculum and scheduling mechanism, which is the operational core of α-Flow—how α is annealed, what the sigmoid schedule parameters control, and why clamping at $\eta = 5 \times 10^{-3}$ matters.
• Sixth, the design space of $L_\alpha$ for $\alpha > 0$, including the choice of shift velocity $\tilde{v}_{s,t}$, the role (or absence) of EMA, and the adaptive loss derivation—these are the hyperparameter decisions that distinguish α-Flow's discrete regime from Shortcut Models and ensure efficient convergence.

3.4 Detailed, Sentence-Based Technical Breakdown

This is primarily an analysis-and-improvement paper whose core idea is that MeanFlow's training difficulty stems from jointly optimizing two gradient-conflicting objectives, and that a curriculum strategy annealing the consistency step ratio α from 1 to 0 can resolve this conflict, reducing reliance on border-case supervision while achieving better few-step generation.

MeanFlow Loss Decomposition: Revealing the Two Conflicting Objectives

The starting point of the paper's technical contribution is the algebraic decomposition of the MeanFlow training loss. The original MeanFlow objective (Equation 5) is:

$L_{\text{MF}}(\theta) = \mathbb{E}_{t, r, z_t} \left[ \left\| u_\theta(z_t, r, t) - v_t + (t - r) \frac{du_{\theta^-}(z_t, r, t)}{dt} \right\|_2^2 \right]$

where $u_\theta(z_t, r, t)$ is the model's predicted mean velocity over the interval $[r, t]$ given the noisy latent $z_t$, $v_t = \epsilon - x$ is the ground-truth instantaneous velocity at timestep $t$ (derived from the flow matching forward process $z_t = (1-t)x + t\epsilon$), and $\frac{du_{\theta^-}(z_t, r, t)}{dt}$ is the total derivative of the target network's output with respect to timestep, computed via Jacobian-vector product. The target network $u_{\theta^-}$ is typically an exponential moving average of the online network, denoted with a stop-gradient operation.

What it computes: The squared L2 distance between the model's velocity prediction and a target that combines the ground-truth velocity with a correction term involving the temporal derivative of the target model's prediction. This correction term $(t-r) \frac{du_{\theta^-}}{dt}$ is what makes MeanFlow different from vanilla flow matching—it adjusts the target to account for the fact that the model is predicting an average velocity over an interval rather than an instantaneous velocity at a point.

Why this form: The mean velocity formulation allows the model to take large jumps during inference (from $t$ directly to $r$) by predicting the average rate of change over that interval. If the model were trained only on instantaneous velocities (as in standard flow matching), large jumps would accumulate significant discretization error because the velocity field changes between $t$ and $r$. The derivative correction term $-(t-r) \frac{du_{\theta^-}}{dt}$ is a first-order Taylor correction that approximates this accumulated change, making the target more accurate for large step sizes.

However, expanding the squared norm and regrouping terms reveals a hidden structure. As shown in Appendix D.1, the MeanFlow loss decomposes into:

$L_{\text{MF}}(\theta) = \underbrace{\mathbb{E}_{t, r, z_t} \left[ \|u_\theta(z_t, r, t) - v_t\|_2^2 \right]}_{\text{Trajectory flow matching } L_{\text{TFM}}} + \underbrace{\mathbb{E}_{t, r, z_t} \left[ 2(t - r) \cdot u_\theta^\top(z_t, r, t) \frac{du_{\theta^-}(z_t, r, t)}{dt} \right]}_{\text{Trajectory consistency } L_{\text{TCc}}} + C$

where $C$ is a term that does not depend on the model parameters $\theta$ (it involves only the ground-truth velocity and the derivative of the target network, both of which are treated as constants with respect to the online parameters), and $\top$ denotes vector transpose.

What each term means operationally:

• $L_{\text{TFM}}$ (trajectory flow matching): This is a flow matching loss where the model receives an additional input $r$ (the target endpoint) but the supervision target $v_t$ does not depend on $r$. The model is being asked to predict the instantaneous velocity at $t$ regardless of what interval endpoint $r$ is specified. This teaches the model the correct velocity field at every point along the trajectory. The expectation is taken over the joint distribution $p(t, r)$ where $r \leq t$.

• $L_{\text{TCc}}$ (trajectory consistency): This is a continuous-time consistency loss scaled by the interval length $(t - r)$. It penalizes the inner product between the model's current prediction and the temporal derivative of the target model's prediction. Following the derivation in Song et al. (2023) (Remark 10), this term is equivalent to minimizing the difference between $u_\theta(z_t, r, t)$ and $u_{\theta^-}(z_{t-\Delta t}, r, t-\Delta t)$ as $\Delta t \to 0$—in other words, it enforces that the model's prediction from a noisy state at $t$ is consistent with its prediction from the slightly less noisy state at $t - \Delta t$, for any target endpoint $r$. This is the "trajectory" generalization of consistency: it's not just consistency to $r = 0$ (as in vanilla consistency models), but consistency across the entire trajectory.

Why this decomposition matters: $L_{\text{TFM}}$ and $L_{\text{TCc}}$ pull the model in fundamentally different directions. $L_{\text{TFM}}$ forces the model to match a specific ground-truth velocity $v_t$—a narrow, high-precision target. $L_{\text{TCc}}$ forces the model's outputs to be smooth and self-consistent across timesteps, but without any absolute reference point. Without a boundary condition, $L_{\text{TCc}}$ alone would collapse to a trivial solution (e.g., predicting zero everywhere, or a constant). The observation that MeanFlow doesn't collapse means that $L_{\text{TFM}}$ is implicitly providing the boundary condition, anchoring the consistency optimization to the correct velocity field. But this anchoring comes at a cost: the two objectives fight each other during joint optimization.

A critical subtlety: the $L_{\text{TFM}}$ term involves random $r \leq t$, while the border-case flow matching supervision commonly used in MeanFlow ($r = t$ for 75% of samples, denoted $L_{\text{FM}'}$) only operates on the $r = t$ slice of this distribution:

$L_{\text{FM}'}(\theta) = \mathbb{E}_{t, r, z_t \mid r=t} \left[ \|u_\theta(z_t, r, t) - v_t\|_2^2 \right]$

When $r = t$, the interval length is zero, so $L_{\text{TCc}}$ vanishes (the $(t-r)$ factor becomes zero). This means $L_{\text{FM}'}$ is a subset of $L_{\text{TFM}}$ that operates exclusively where the consistency term exerts no gradient. The paper's key insight is that this geometric property—$L_{\text{FM}'}$ lives entirely on the $r = t$ manifold where $L_{\text{TCc}} = 0$—makes it a less antagonistic surrogate for $L_{\text{TFM}}$ than the full $L_{\text{TFM}}$ loss.

Gradient Conflict Analysis: Why Joint Optimization Fails

The decomposed loss structure sets up the paper's central empirical finding: the gradients of $L_{\text{TFM}}$ and $L_{\text{TCc}}$ are strongly negatively correlated during training, making joint optimization inherently difficult. The analysis is conducted by training a DiT-B/2 model (131M parameters, the non-CFG ablation variant from Table 3) on ImageNet-1K 256×256 for 400K iterations using standard MeanFlow training.

The gradient similarity measurement works as follows: at each checkpoint during training, the authors compute the full gradient vectors $\nabla_\theta L_{\text{TFM}}$, $\nabla_\theta L_{\text{TCc}}$, $\nabla_\theta L_{\text{FM}'}$, and $\nabla_\theta L_{\text{MF}}$ on the same batch of 128 samples, using 1000 repeated measurements to compute mean cosine similarities and their 5th/95th percentile confidence bounds. The cosine similarity between two gradient vectors $\nabla_a$ and $\nabla_b$ is $\cos(\nabla_a, \nabla_b) = \frac{\nabla_a^\top \nabla_b}{\|\nabla_a\| \|\nabla_b\|}$, measuring their directional alignment: +1 means perfectly aligned (optimizing one helps the other), 0 means orthogonal (independent), and −1 means perfectly opposed (optimizing one hurts the other).

Key finding from Figure 2a: The cosine similarity between $\nabla L_{\text{TFM}}$ and $\nabla L_{\text{TCc}}$ (shown as cos(∇L_TFM, ∇L_TCc) in orange) is consistently below −0.4 throughout training. This means that taking a gradient step to reduce $L_{\text{TFM}}$ inherently increases $L_{\text{TCc}}$, and vice versa—the optimization landscape has a saddle-like structure where progress on one front requires retreat on the other. The paper hypothesizes that this arises because $L_{\text{TCc}}$ (without a boundary condition) has a very large optimal solution manifold—many different velocity fields can be self-consistent—while $L_{\text{TFM}}$ has a very narrow optimal solution manifold (essentially just the true velocity field). The joint optimization is pulled toward the large $L_{\text{TCc}}$ manifold, distracting from reaching the narrow intersection where both objectives are minimized.

Contrast this with the cosine similarity between $\nabla L_{\text{FM}'}$ and $\nabla L_{\text{TCc}}$ (shown as cos(∇L_FM', ∇L_TCc) in blue in Figure 2a): it is consistently higher (less negative) than $\cos(\nabla L_{\text{TFM}}, \nabla L_{\text{TCc}})$. This confirms the geometric intuition: $L_{\text{FM}'}$ operates at $r = t$ where $L_{\text{TCc}}$ contributes no gradient, so the gradients of $L_{\text{FM}'}$ interfere less with the consistency optimization. $L_{\text{FM}'}$ serves as a gradient-friendly surrogate: it pushes the model toward the correct velocity field (like $L_{\text{TFM}}$) but with significantly less conflict against the consistency term.

Corroborating evidence from Figures 2b and 2c: Figure 2b shows that when MeanFlow is trained with 75% $r = t$ (blue curve), the evaluated $L_{\text{TFM}}$ (computed over random $r$, not just $r = t$) is substantially lower throughout training compared to 0% $r = t$ (orange curve). This confirms that $L_{\text{FM}'}$ is an effective surrogate—spending 75% of compute on the border case genuinely improves performance on the full trajectory flow matching objective, even though $L_{\text{FM}'}$ only covers a measure-zero subset of the $p(t, r)$ distribution.

Figure 2c shows the surprising result that $L_{\text{TCc}}$ is actually lower (better) with 75% $r = t$ supervision than with 0%, suggesting that improving $L_{\text{TFM}}$ indirectly helps the consistency optimization by anchoring it to a better velocity field. The consistency loss, the paper argues, is "relatively easy to optimize, even near the $L_{\text{TFM}}$ optimum"—once the model has a good velocity estimate, self-consistency follows naturally.

Additional gradient analysis in Appendix J, Figure 6: The appendix provides a full 3×2 grid of gradient cosine similarities between all pairs of losses ($L_{\text{TFM}}$, $L_{\text{FM}'}$, $L_{\text{TCc}}$, $L_{\text{MF}}$) for both 0% and 75% $r = t$ ratios. Key observations: (1) $\cos(\nabla L_{\text{TFM}}, \nabla L_{\text{FM}'})$ is very high (~0.7–0.9) with 0% $r = t$, confirming they are closely aligned objectives when both are active, but drops slightly with 75% $r = t$ because the model sees less full $L_{\text{TFM}}$; (2) $\cos(\nabla L_{\text{MF}}, \nabla L_{\text{TFM}})$ is moderate (~0.4–0.6), showing that the MeanFlow total gradient is a compromise between the conflicting components; (3) $\cos(\nabla L_{\text{MF}}, \nabla L_{\text{TCc}})$ is also moderate (~0.3–0.5), confirming neither component dominates the total gradient direction.

Implications for the design of α-Flow: The gradient conflict analysis provides the mechanistic justification for the curriculum strategy. If $L_{\text{TFM}}$ and $L_{\text{TCc}}$ cannot be optimized jointly without interference, then optimize them sequentially: first establish the narrow $L_{\text{TFM}}$ manifold (where gradient directions are clear and variance is low), then gradually introduce the consistency objective (which is easier to optimize near the correct velocity field), and finally fine-tune purely on the MeanFlow objective (which combines both). This temporal decoupling is the core algorithmic insight of α-Flow.

The α-Flow Loss: Definition and Geometry

The α-Flow loss is defined in Equation 8 as:

$L_\alpha(\theta) = \mathbb{E}_{t, r, z_t} \left[ \alpha^{-1} \cdot \left\| u_\theta(z_t, r, t) - \left( \alpha \cdot \tilde{v}_{s,t} + (1 - \alpha) \cdot u_{\theta^-}(z_s, r, s) \right) \right\|_2^2 \right]$

where $t$ is the start timestep (closer to noise), $r \in [0, 1]$ is the target endpoint (closer to data) with $r \leq t$, $s = \alpha \cdot r + (1 - \alpha) \cdot t$ is the intermediate timestep determined by the consistency step ratio $\alpha \in (0, 1]$, $z_t = (1-t)x + t\epsilon$ is the noisy latent at timestep $t$, $\tilde{v}_{s,t}$ is the "shift velocity" used to estimate $z_s$ from $z_t$ via $z_s = z_t - (t - s) \cdot \tilde{v}_{s,t}$, and $u_{\theta^-}$ is the target network (stop-gradient applied).

What this loss computes structurally: The model at timestep $t$ predicts a velocity $u_\theta(z_t, r, t)$. The target is an $\alpha$-weighted interpolation between the shift velocity $\tilde{v}_{s,t}$ (which carries the ground-truth information about how the latent should change) and the target model's own prediction $u_{\theta^-}(z_s, r, s)$ evaluated at the intermediate state $z_s$ (which carries the self-consistency constraint). At $\alpha = 1$, the target is purely $\tilde{v}_{s,t}$ (flow matching). At $\alpha \to 0$, the target is dominated by $u_{\theta^-}(z_s, r, s)$ (consistency training), and the $\alpha^{-1}$ prefactor blows up—but as Theorem 1 shows, the gradient of $L_\alpha$ converges to the gradient of $L_{\text{MF}}$ as $\alpha \to 0$, so this divergence in the loss value does not cause gradient instability.

The role of each parameter:

• $\alpha$ (consistency step ratio): Controls the relative position of $s$ within the $[r, t]$ interval. When $\alpha = 1$, $s = r$ (the intermediate point is at the target endpoint), so the model is evaluated at $z_s = z_r$, which is nearly clean data—this reduces to flow matching because the target is essentially just $\tilde{v}_{s,t}$. When $\alpha = 0.5$, $s$ is exactly halfway between $r$ and $t$—this is a single "shortcut" step across half the interval. When $\alpha \to 0$, $s \to t$—the intermediate point approaches the current noisy state, making the consistency constraint local.

• $\tilde{v}_{s,t}$ (shift velocity): Determines how $z_s$ is estimated from $z_t$. The paper explores two choices: setting $\tilde{v}_{s,t} = v_t$ (the ground-truth instantaneous velocity) or $\tilde{v}_{s,t} = u_{\theta^-}(z_t, s, t)$ (the target model's own prediction of the mean velocity from $t$ to $s$). The first choice uses oracle knowledge and provides a lower-variance target; the second choice bootstraps from the model itself, creating a self-consistency loop.

• $u_{\theta^-}$ (target network): The stop-gradient version of the model used for the self-consistency term. Whether to use an exponential moving average (EMA) of the online network or simply the most recent checkpoint (non-EMA) is an important design choice explored in the ablation.

The $\alpha^{-1}$ prefactor: This scaling is not arbitrary—it is derived from the relationship between discrete and continuous consistency losses. As $\alpha \to 0$, $L_\alpha$ diverges as $\alpha^{-1}$, but its gradient converges to $\nabla_\theta L_{\text{MF}}$. The prefactor ensures that the effective learning rate for the consistency signal remains stable as $\alpha$ varies. Without it, the consistency gradient would vanish as $\alpha$ decreases, making it impossible to transition smoothly to MeanFlow.

Visual geometry (Figure 3e): The α-Flow training trajectory works as follows: given a noisy sample $z_t$, the model predicts the mean velocity $u_\theta(z_t, r, t)$ that would carry the sample to timestep $r$. To check this prediction, the loss estimates where the sample should be at intermediate timestep $s$ using the shift velocity ($z_s = z_t - (t-s)\tilde{v}_{s,t}$), evaluates the target model's prediction at that intermediate state, and requires that the current prediction be consistent with this intermediate prediction—but with a weight $\alpha$ on the oracle velocity and $(1-\alpha)$ on the bootstrapped prediction. This creates a "soft" consistency constraint that can be tuned from hard ground-truth matching ($\alpha = 1$) to pure self-consistency ($\alpha \to 0$).

Unification Theorem: α-Flow as a General Framework

Theorem 1 establishes that six previously distinct training objectives are special cases of $L_\alpha$:

1. Trajectory flow matching ($L_{\text{TFM}}$): $L_{\alpha=1}$ with $\tilde{v}_{s,t} = v_t$. When $\alpha = 1$, the intermediate timestep $s$ equals $r$ (the target endpoint). The target becomes $1 \cdot \tilde{v}_{s,t} + 0 \cdot u_{\theta^-}(z_s, r, s) = \tilde{v}_{s,t} = v_t$. The $\alpha^{-1}$ prefactor becomes $1$. The loss reduces to $\mathbb{E}[\|u_\theta(z_t, r, t) - v_t\|_2^2]$, which is exactly $L_{\text{TFM}}$—the model predicts the instantaneous velocity regardless of the specified endpoint $r$.

2. Shortcut Model ($L_{\text{SC}}$): $L_{\alpha=1/2}$ with $\tilde{v}_{s,t} = u_{\theta^-}(z_t, s, t)$, scaled by $1/2$. When $\alpha = 0.5$, the intermediate $s$ is the midpoint of $[r, t]$. The shift velocity is the target model's own prediction of the mean velocity from $t$ to $s$. The target combines this bootstrap estimate (weight $\alpha$) with the target model's prediction at $z_s$ (weight $1-\alpha$). The loss $L_{\alpha=1/2}$ with these choices is $2 \cdot L_{\text{SC}}$, where $L_{\text{SC}}$ is Equation 4—enforcing that the direct jump from $t$ to $r$ matches two consecutive half-sized jumps through $s$.

3. MeanFlow ($L_{\text{MF}}$): $\nabla_\theta L_{\alpha \to 0} = \nabla_\theta L_{\text{MF}}$ with $\tilde{v}_{s,t} = v_t$. As $\alpha \to 0$, $s \to t$ (the intermediate point approaches the current timestep). In this limit, the loss value diverges, but the gradient converges to the MeanFlow gradient. The proof (Appendix D.2) involves Taylor-expanding $u_{\theta^-}(z_s, r, s)$ around $(z_t, t)$, showing that:

$u_{\theta^-}(z_s, r, s) = u_{\theta^-}(z_t, r, t) - \frac{du_{\theta^-}(z_t, r, t)}{dt} (t-s) + \mathcal{O}((t-s)^2)$

and substituting into the loss expression, which in the limit recovers the $v_t - (t-r) \frac{du_{\theta^-}}{dt}$ target structure of MeanFlow. The key technical detail: the $\alpha^{-1}$ scaling exactly compensates for the $(t-s) = \alpha(t-r)$ factor, preventing the gradient from vanishing as $\alpha \to 0$.

4. Discrete consistency training ($L_{\text{CTd}}$): $L_{\alpha=\delta}$ for $\delta \in (0, t)$ with $r \equiv 0$, $\tilde{v}_{s,t} = v_t$, and $z_0$-parameterization $u_\theta(z_t, 0, t) = (z_t - f_\theta(z_t, t))/t$. Setting $r = 0$ collapses the trajectory consistency to a single endpoint (clean data). The $z_0$-parameterization re-expresses the velocity prediction as a direct mapping to clean data. Substituting these into $L_\alpha$ with $\alpha = \delta$ yields:

$L_\alpha = \mathbb{E}_{t, z_t} \left[ \frac{1}{t \cdot \delta} \cdot \|f_\theta(z_t, t) - f_{\theta^-}(z_{t-\delta}, t - \delta)\|_2^2 \right]$

which is the discrete CT loss (Equation 2) with a specific loss weighting $1/(t\delta)$. The weighting emerges naturally from the $z_0$-parameterization and the $\alpha^{-1}$ prefactor.

5. Continuous consistency training ($L_{\text{CTc}}$): $\nabla_\theta L_{\alpha \to 0} = \nabla_\theta L_{\text{CTc}}$ with the same $r = 0$, $z_0$-parameterization as above. Taking the $\alpha \to 0$ limit and substituting the parameterization yields the continuous CT gradient (Equation 3), which involves the Jacobian-vector product $\nabla_\theta f_\theta(z_t, t) \cdot \frac{df_{\theta^-}(z_t, t)}{dt}$.

Why this unification is powerful practically: The theorem means that α-Flow is not a new point in the design space but a parameterized curve through it. By changing $\alpha$, you move along a continuum from pure supervised learning ($\alpha = 1$, low variance, high bias for few-step generation) to pure self-consistency ($\alpha \to 0$, low bias, high variance). The curriculum strategy simply traverses this curve during training, spending time at each $\alpha$ value proportional to its usefulness for convergence. This is fundamentally different from the mixture approach used in MeanFlow (75% $L_{\text{FM}'}$ + 25% $L_{\text{MF}}$), which simultaneously pulls in two directions at every step.

The Three-Phase Curriculum: Temporal Decoupling of Conflicting Objectives

The α-Flow curriculum is defined by the schedule function $\alpha(k)$ where $k$ is the training iteration. The schedule uses a sigmoid function (Algorithm 2) parameterized by four values:

• $k_s$ (start iteration): The iteration at which α begins decreasing from 1. Before $k_s$, $\alpha = 1$ (pure trajectory flow matching). This is the "pretraining" phase.
• $k_e$ (end iteration): The iteration at which α reaches its minimum (clamped to the clamping value). After $k_e$, $\alpha \approx 0$ (MeanFlow fine-tuning).
• $\gamma$ (temperature): Controls the steepness of the sigmoid transition. Set to 25, which makes the transition relatively sharp (most of the change in α occurs over ~50K–100K iterations). Higher $\gamma$ makes the transition sharper; lower $\gamma$ makes it more gradual.
• $\eta$ (clamping value): Forces α to exactly 0 when it would otherwise be less than $\eta$, and exactly 1 when it would be greater than $1 - \eta$. Set to $\eta = 5 \times 10^{-3}$ based on ablation in Table 5(c).

The sigmoid function is computed as (Algorithm 2):

scale = 1 / (k_e - k_s)
offset = -(k_s + k_e) / 2 / (k_e - k_s)
alpha = 1 - sigmoid((scale * k + offset) * gamma)

This produces a curve that starts at approximately 1 (sigmoid of a negative number $\approx$ 0), transitions through a smooth S-shape, and ends at approximately 0 (sigmoid of a positive number $\approx$ 1). Figure 5 visualizes several example schedules.

Phase 1: Trajectory flow matching pretraining ($\alpha = 1$, $k < k_s$): During this phase, the model sees only $L_{\alpha=1}$ with $\tilde{v}_{s,t} = v_t$, which reduces exactly to trajectory flow matching ($L_{\text{TFM}}$). The training objective is:

$L_{\alpha=1}(\theta) = \mathbb{E}_{t, r, z_t} \left[ \|u_\theta(z_t, r, t) - v_t\|_2^2 \right]$

This is standard flow matching but with the model receiving an additional $r$ input (even though it's not used in the target). The purpose of this phase is to quickly establish a good noise-to-data velocity field. Since flow matching is a low-variance, well-conditioned objective (it's supervised regression against ground-truth velocities), the model converges rapidly to a reasonable approximation of the true velocity field. This provides a strong initialization for the subsequent consistency phases.

The paper explicitly connects this to prior work: Geng et al. (2025b) also used diffusion model pretraining for consistency models, but with different motivations. In α-Flow, the pretraining arises directly from the gradient conflict analysis—since optimizing $L_{\text{TFM}}$ and $L_{\text{TCc}}$ jointly is inefficient, it is better to front-load the $L_{\text{TFM}}$ optimization where there is no $L_{\text{TCc}}$ interference.

Phase 2: α-Flow transition ($\alpha \in (0, 1)$, $k_s \leq k \leq k_e$): As α decreases from 1 toward 0, the training objective smoothly transitions between trajectory flow matching and MeanFlow. At any given α, the loss is:

$L_\alpha(\theta) = \alpha^{-1} \cdot \|\Delta\|_2^2, \quad \Delta = u_\theta(z_t, r, t) - (\alpha v_t + (1-\alpha) u_{\theta^-}(z_s, r, s))$

where $s = \alpha r + (1-\alpha) t$ and $z_s = z_t - (t-s) v_t$ (using $\tilde{v}_{s,t} = v_t$).

Several things happen as α decreases:

• Bias-variance transition: At $\alpha = 1$, the target is purely $v_t$ (low variance because it's a fixed ground-truth value, high bias because matching the instantaneous velocity doesn't perfectly train for few-step generation). At $\alpha \to 0$, the target is dominated by $u_{\theta^-}(z_s, r, s)$ (low bias for few-step generation because it enforces trajectory consistency, higher variance because the target is bootstrapped from the model itself).

• Interval length grows: As α decreases, $s$ moves closer to $t$, so the self-consistency check involves a smaller temporal jump $(t-s)$. Smaller jumps mean lower discretization error in the consistency constraint, improving the quality of the consistency signal.

• Gradient conflict naturally handled: By interpolating between the two objectives rather than mixing them, the model at each iteration receives a single coherent gradient direction (the gradient of $L_\alpha$) rather than conflicting gradients from two separate loss terms. The $\alpha$-weighted target smoothly rotates the gradient direction from the $L_{\text{TFM}}$ direction toward the $L_{\text{MF}}$ direction.

Phase 3: MeanFlow fine-tuning ($\alpha \to 0$, $k > k_e$): Once α reaches the clamping value $\eta$, the loss switches to the pure MeanFlow objective ($L_{\text{MF}}$, Equation 5). At this point, the model has already established a good velocity field (from Phase 1) and learned trajectory consistency (from Phase 2), so the full MeanFlow objective can be optimized without the gradient conflict that plagued joint training from scratch.

A crucial practical detail: the MeanFlow phase still uses some border-case flow matching supervision (the $r = t$ ratio), but significantly less than vanilla MeanFlow—Table 2(b) shows α-Flow achieves its best 1-NFE performance at 25% $r = t$ ratio, compared to 75% for MeanFlow. The pretraining on trajectory flow matching means the model doesn't need $L_{\text{FM}'}$ as heavily to maintain the velocity field quality.

The clamping value choice ($\eta = 5 \times 10^{-3}$): Table 5(c) ablates fixed α values for a model pretrained on flow matching for 200K iterations and then fine-tuned on α-Flow for another 200K. The results show:

• $\alpha = 10^{-2}$: FID 49.7, FDD 845.2
• $\alpha = 5 \times 10^{-3}$: FID 46.2, FDD 860.8 (best FID)
• $\alpha = 2 \times 10^{-3}$: FID 50.3, FDD 833.0 (best FDD)
• $\alpha = 10^{-3}$: FID 57.2, FDD 863.7

The optimal α is $5 \times 10^{-3}$—small enough that the consistency constraint is accurate (small discretization error), but large enough that gradients remain well-behaved. The clamping value causes the schedule to treat any α $< 5 \times 10^{-3}$ as exactly 0 (switching to the JVP-based MeanFlow objective), and any α $> 1 - 5 \times 10^{-3}$ as exactly 1 (switching to pure flow matching for efficiency, since $L_{\alpha \approx 1}$ and $L_{\text{TFM}}$ are very similar but $L_{\text{TFM}}$ is simpler).

Ablation over schedule parameters (Table 2a, Figure 5): The paper investigates the effect of varying $k_s$ (the start of the transition) while keeping the transition duration $k_e - k_s$ fixed at 100K iterations:

• $k_s = 0$K (transition from start): Constant0.0 baseline, which is just MeanFlow. FID: 44.4 (NFE=1), 42.1 (NFE=2).
• $k_s = 50$K: FID 44.1 (NFE=1), 39.9 (NFE=2).
• $k_s = 100$K: FID 42.4 (NFE=1), 38.3 (NFE=2).
• $k_s = 150$K: FID 41.3 (NFE=1), 38.1 (NFE=2)—best performance for fixed 100K transition.

Increasing $k_s$ (longer flow matching pretraining) consistently improves performance, confirming that robust early-stage velocity estimation is critical. The optimal $k_s = 150$K for the DiT-B/2 model means spending ~37.5% of training on pure flow matching.

The paper also varies the transition duration with the midpoint fixed at 200K:

• 0K transition (instantaneous switch at 200K): FID 41.4, worse than gradual.
• 100K transition (150K→250K): FID 41.3 (best).
• 400K transition (0K→400K, starts transitioning immediately): FID 40.0 for NFE=1, 37.1 for NFE=2—best overall metrics.

Longer, smoother transitions produce better results, which aligns with the bias-variance intuition: a gradual reduction in bias (increasing self-consistency weight) allows the model to adapt its velocity field incrementally rather than being shocked by a sudden change in the training objective.

Design Space of $L_\alpha$ for $\alpha > 0$: Shift Velocity, EMA, and Adaptive Weighting

When $\alpha > 0$, the α-Flow loss does not require Jacobian-vector products—it is a purely discrete objective that can be computed with standard forward passes. However, several design choices distinguish α-Flow's discrete regime from Shortcut Models and affect convergence.

Shift velocity choice ($\tilde{v}_{s,t}$): The paper ablates two options in Table 5(a), using a DiT-B/2-non-cfg model pretrained on flow matching for 200K iterations and fine-tuned on α-Flow with α fixed at $10^{-2}$:

• $\tilde{v}_{s,t} = v_t$ (ground-truth instantaneous velocity): The shift velocity is the true velocity at timestep $t$ from the flow matching forward process. This gives the model direct access to ground-truth information about how the latent should change. Result: FID 59.2, FDD 964.6.
• $\tilde{v}_{s,t} = u_{\theta^-}(z_t, s, t)$ (target model's own prediction): The shift velocity is bootstrapped from the target model—the model estimates how the latent would change from $t$ to $s$, and then uses this estimate to compute $z_s$. This is the approach used by Shortcut Models (Frans et al., 2025). Result: FID 319.0, FDD 4009.9—dramatically worse.

The paper concludes that the bootstrapped shift velocity only works when α is large (specifically $\alpha = 0.5$ in Shortcut Models). When α is small (close to 0), the bootstrap estimate is too noisy for stable training. Using the ground-truth $v_t$ provides a clean anchor that stabilizes optimization, even as the self-consistency term becomes dominant.

EMA for $u_{\theta^-}$: Table 5(a) also ablates whether to use an exponential moving average of the online network for the target $u_{\theta^-}$:

• EMA: FID 188.1, FDD 1761.6 (with $\tilde{v}_{s,t} = u_{\theta^-}$) or 202.8, 1832.3 (with $v_t$)
• Non-EMA (using the most recent checkpoint): FID 319.0, FDD 4009.9 (with $\tilde{v}_{s,t} = u_{\theta^-}$) or 59.2, 964.6 (with $v_t$)

Non-EMA performs significantly better when combined with ground-truth shift velocity. The paper speculates that EMA stabilizes bootstrapping approaches but is unnecessary—and potentially harmful—when the target is grounded in oracle velocities. Using the most recent model as $u_{\theta^-}$ means the consistency constraint is applied to the model's own current beliefs, which may provide a more effective learning signal.

Adaptive loss weighting: The MeanFlow paper introduced an adaptive loss weight $\omega = 1 / (\|\Delta\|_2^2 + c)$ where $c = 10^{-3}$ is a small constant, and the adaptively weighted loss is $\text{sg}(\omega) \cdot \|\Delta\|_2^2$ (where $\text{sg}$ is the stop-gradient operator). This prevents high-error samples (which occur due to the high variance of consistency training) from dominating the gradient.

For α-Flow, the paper derives an α-specific adaptive weight. Starting from the relationship between $L_\alpha$ and $L_{\text{MF}}$:

$\lim_{\alpha \to 0} L_\alpha = \alpha \cdot L_{\text{MF}}$

When α is small, $L_\alpha \approx \alpha \cdot L_{\text{MF}}$, so $L_{\text{MF}} \approx L_\alpha / \alpha$. The adaptive weight should be based on $L_{\text{MF}}$ (the effective loss driving the consistency signal), giving:

$\omega = \frac{1}{L_{\text{MF}} + c} \approx \frac{1}{L_\alpha / \alpha + c} = \frac{\alpha}{L_\alpha + \alpha c} \approx \frac{\alpha}{L_\alpha + c}$

since both α and c are very small. The final adaptive weight is:

$\omega = \frac{\alpha}{\|\Delta\|_2^2 + c}$

and the weighted loss is $\text{sg}(\omega) \cdot \|\Delta\|_2^2$ (not $\alpha^{-1} \cdot \|\Delta\|_2^2$—the $\alpha^{-1}$ scaling from the loss definition is absorbed differently; the implementation in Algorithm 1 uses $\text{loss} = \text{metric}(\text{error})$ where the metric can be either adaptive or standard).

Ablation in Table 5(b): Comparing different loss weightings for DiT-B/2-non-cfg with α fixed at $10^{-2}$:

• $\omega = 1$ (no adaptive weight): FID 59.2, FDD 964.6
• $\omega = 1 / (\|\Delta\|_2^2 + c)^{0.5}$: FID 55.0, FDD 918.5
• $\omega = 1 / (\|\Delta\|_2^2 + c)$ (original MeanFlow weight): FID 52.2, FDD 883.6
• $\omega = \alpha / (\|\Delta\|_2^2 + c)$ (proposed α-scaled weight): FID 49.7, FDD 845.2

The α-scaled weight performs best, confirming the derivation. It accounts for the fact that when α is small, the raw error $\|\Delta\|_2^2$ is scaled down (because the target is dominated by $u_{\theta^-}$ which is close to $u_\theta$), so the adaptive weight needs to compensate with an α factor.

Overall ablation progression (Table 5d): Building up from a Shortcut Model baseline (FID 59.8):

• • $\tilde{v}_{s,t} = v_t$: FID 59.2 (marginally better than $u_{\theta^-}$)
• • Adaptive loss ($\omega = \alpha / (\|\Delta\|_2^2 + c)$): FID 49.7 (significant improvement)
• • Optimal α ($5 \times 10^{-3}$): FID 45.6 (further improvement from better consistency accuracy)
• MeanFlow baseline: FID 43.3 (still slightly better than fixed-α α-Flow)

The gap between fixed-α α-Flow (45.6) and MeanFlow (43.3) suggests that the continuous MeanFlow objective ($\alpha \to 0$) provides additional benefit beyond the best discrete α. This motivates the full curriculum strategy: use larger α during training for stability (via the transition phase), then fine-tune with $\alpha \to 0$ to capture the benefits of the continuous consistency constraint. The curriculum approach (using the schedule rather than fixed α) ultimately outperforms both fixed-α α-Flow and MeanFlow, as shown in Table 2.

Classifier-Free Guidance Integration

Classifier-free guidance (CFG) is essential for high-quality conditional image generation. The paper follows MeanFlow's approach for integrating CFG into the α-Flow framework. During training, the shift velocity $\tilde{v}_{s,t}$ in Equation 8 is modified to:

$\tilde{v}_{s,t} = w \cdot v(z_t, t \mid x) + \kappa \cdot u_{\theta^-}(z_t, t, t \mid c) + (1 - w - \kappa) \cdot u_{\theta^-}(z_t, t, t \mid \varnothing)$

where $v(z_t, t \mid x)$ is the ground-truth velocity conditioned on the image (always available during training since $x$ is the training sample), $u_{\theta^-}(\cdot \mid c)$ is the target model's prediction conditioned on the class label, $u_{\theta^-}(\cdot \mid \varnothing)$ is the unconditional prediction, $w$ is the guidance scale for the ground-truth velocity, and $\kappa$ is the guidance scale for the class-conditional prediction.

Configurations from Table 3:

• DiT-B/2: No CFG training (used only for ablation and analysis)
• DiT-XL/2: $w = 0.2$, $\kappa = 0.92$, CFG triggered only when $t \in [0.0, 0.75]$, no EMA for CFG predictions
• DiT-XL/2+: Same CFG settings as DiT-XL/2

The restricted time range for CFG (only applied when $t \leq 0.75$) prevents the model from relying on CFG in the high-noise regime where class information is less reliable, stabilizing training. The EMA for CFG is explicitly disabled (the target model $u_{\theta^-}$ is always used for consistency targets, not an EMA-smoothed version).

During inference, standard CFG sampling is used: the model's prediction is computed as a weighted combination of conditional and unconditional predictions, with guidance scales chosen to balance sample quality and diversity.

Sampling: ODE vs. Consistency Sampling

α-Flow supports both ODE sampling (following the learned vector field) and consistency sampling (directly jumping from noise to data using the model's $r=0$ prediction). Algorithm 3 provides the sampling procedures:

ODE sampling: Starting from $z_{t_1} \sim \mathcal{N}(0, I)$, for each pair of consecutive timesteps $(t_n, t_m)$ where $t_n > t_m$: $z_{t_m} = z_{t_n} - (t_n - t_m) \cdot u_\theta(z_{t_n}, r = t_m, t = t_n)$ This is a standard Euler step following the predicted mean velocity from $t_n$ to $t_m$.

Consistency sampling: Starting from $z_{t_1} \sim \mathcal{N}(0, I)$, for each pair of consecutive timesteps: $z_{t_m} = z_{t_n} - t_n \cdot u_\theta(z_{t_n}, r = 0, t = t_n) + t_m \cdot \epsilon, \quad \epsilon \sim \mathcal{N}(0, I)$ This jumps directly from $t_n$ to the data manifold (using the model's prediction to $r=0$), then adds back noise to reach $t_m$. This is the standard consistency sampling procedure from Song et al. (2023).

Empirical findings (Figure 4): For DiT-XL/2 models, consistency sampling outperforms ODE sampling for α-Flow, achieving best FID of 2.09 at intermediate timestep 0.4 for α-Flow-XL/2, compared to ODE's best of 2.32 at timestep 0.35. The paper hypothesizes that consistency sampling benefits more from better convergence (α-Flow achieves lower training loss), as it relies more heavily on the model's ability to make accurate large jumps. For the smaller DiT-B/2 models, ODE sampling is used (as specified in Table 1), suggesting that smaller models may not have sufficient capacity for accurate consistency sampling, though no explicit ablation at the B/2 scale is provided.

For MeanFlow-XL/2, the pattern reverses: ODE sampling (best FID 2.39 at timestep 0.35) outperforms consistency sampling, indicating that MeanFlow's training may produce velocity fields better suited for ODE integration than direct consistency mapping—perhaps due to the gradient conflict affecting the quality of the $r=0$ prediction.

The selected intermediate timesteps for 2-NFE sampling (Table 1) are chosen to balance FID and FDD: 0.5 for most configurations, 0.55 for α-Flow-XL/2 with consistency sampling, 0.35 for MeanFlow-XL/2 with ODE sampling. These values align with the common practice in the consistency model literature, where intermediate timesteps around 0.4–0.6 are typically optimal for 2-step generation.

Summary of Design Choices and Their Justifications

• Sigmoid curriculum schedule with annealing α over fixed α or pure MeanFlow: Based on the gradient conflict analysis showing that $L_{\text{TFM}}$ and $L_{\text{TCc}}$ cannot be efficiently optimized jointly. Temporal decoupling via annealing avoids the interference while still reaching the low-bias MeanFlow objective.

• $\tilde{v}_{s,t} = v_t$ without EMA over bootstrapped shift velocity with EMA: The ground-truth velocity provides a stable, low-variance anchor that allows α-Flow to work at small α values, unlike Shortcut Models which require α = 0.5 and EMA for stability. The ablation shows bootstrapping fails dramatically at small α (FID 319 vs. 59.2).

• α-scaled adaptive weight $\omega = \alpha/(\|\Delta\|_2^2 + c)$ over the original MeanFlow adaptive weight: Derived from the relationship $L_\alpha \approx \alpha L_{\text{MF}}$ for small α, this weight correctly normalizes the loss to account for the α-dependent scaling of the error term. Empirically provides ~5% FID improvement over the unscaled adaptive weight (49.7 vs. 52.2).

• Clamping α at $\eta = 5 \times 10^{-3}$: Directly from the fixed-α ablation (Table 5c) showing optimal discrete α, with the JVP-based MeanFlow objective used when smaller α would be needed—this captures the benefits of the continuous consistency limit without gradient variance issues at extremely small discrete α.

• Two-fold cross-validation over schedule parameters (implied by the sweeping experiments in Table 2): Different model sizes and training budgets may have different optimal $k_s$, $k_e$, and $r = t$ ratios. The paper sweeps these systematically for DiT-B/2 and transfers the best settings to larger models (with adjustments for the longer training duration—e.g., $k_s = 600$K for XL/2 vs. 150K for B/2).

• Separate prediction heads not used (Appendix C, failed experiments): The paper tried decomposing the model into separate velocity prediction and consistency prediction heads, hypothesizing this might allow each head to specialize. This failed to produce improvements, suggesting that the conflict is in the optimization landscape, not in the model architecture—the same parameters need to represent both the velocity field and the self-consistency mapping, and the curriculum handles the optimization conflict better than architectural decomposition.

4. Key Insights and Innovations

Innovation 1: The Loss Decomposition as a Diagnostic Framework for Training Dynamics

The paper's most intellectually distinctive contribution is not α-Flow itself, but the decomposition-first methodology that precedes it. Prior work on few-step generative modeling treated training objectives as atomic units: you pick a loss (discrete CT, continuous CT, Shortcut Model, MeanFlow), you tune its hyperparameters, and you evaluate the result. When MeanFlow outperformed competitors, the field's response was largely empirical—sweep the $r = t$ ratio, try different noise schedules, adjust the adaptive loss weight. What was missing was a causal explanation for why these choices mattered.

Zhang et al. break this pattern by decomposing the MeanFlow loss algebraically (Section 3.1, Eq. 6) and showing it is not one objective but two: trajectory flow matching ($L_{\text{TFM}}$) and trajectory consistency ($L_{\text{TCc}}$). This is not a mere algebraic identity—it is a diagnostic instrument. By computing pairwise gradient cosine similarities between these components throughout training (Figure 2a), the paper surfaces the mechanism underlying MeanFlow's training difficulty: the two objectives have strongly negatively correlated gradients (cosine similarity consistently below −0.4), meaning gradient descent is perpetually pulled in opposing directions. The optimization is fighting itself.

Why is this a conceptual advance rather than a computational curiosity? Because it transforms the problem from "how do we make MeanFlow better?" into "how do we resolve gradient conflict between $L_{\text{TFM}}$ and $L_{\text{TCc}}$?" The first question admits endless hyperparameter tuning; the second has a principled answer: temporal decoupling. The gradient conflict analysis also retroactively explains why the border-case $r = t$ supervision (75% of MeanFlow's training budget) is effective: $L_{\text{FM}'}$ operates on the $r = t$ manifold where $L_{\text{TCc}}$ vanishes, so its gradient interferes less with the consistency optimization (Figure 2a, blue vs. orange curves). This elevates a heuristic training trick into a consequence of an understood optimization dynamic.

The broader significance is that the paper establishes gradient conflict as a first-class diagnostic in generative model training, analogous to how the multi-task learning literature analyzes gradient interference (Yu et al., 2020) or how the RLHF community diagnoses reward hacking through gradient pathology. This reframes future work: rather than designing new objectives and hoping they train well, one can decompose a candidate objective, measure gradient alignment, and design curriculum strategies informed by the conflict structure. The decomposition itself is the innovation; α-Flow is its first application.

Evidence anchor: Figure 2a shows $\cos(\nabla L_{\text{TFM}}, \nabla L_{\text{TCc}})$ is negative and below −0.4 throughout 400K training iterations, while $\cos(\nabla L_{\text{FM}'}, \nabla L_{\text{TCc}})$ is consistently higher. Figure 6 in Appendix J provides the full 3×2 gradient similarity matrix, confirming the specificity of the $L_{\text{TFM}}$–$L_{\text{TCc}}$ conflict.

Distinction from prior work: Song et al. (2023) and Geng et al. (2025b) studied the bias-variance tradeoff in consistency training, but their analysis focused on discretization error as a function of $\Delta t$, not on gradient-level interactions between loss components. MeanFlow (Geng et al., 2025a) identified that $r = t$ supervision empirically helps but offered no mechanistic explanation. This paper's gradient analysis fills that gap and converts an empirical observation into a diagnostic principle.

Innovation 2: α-Flow as a Unifying Parameterized Family, Not a Point Solution

The paper's second contribution is the unification theorem (Theorem 1) establishing that the α-Flow loss $L_\alpha$ subsumes five previously distinct training objectives—trajectory flow matching, Shortcut Models, MeanFlow, discrete consistency training, and continuous consistency training—under a single formulation parameterized by the consistency step ratio $\alpha$ and the shift velocity $\tilde{v}_{s,t}$. This is not taxonomic bookkeeping; it is a design-space compression that changes how one thinks about few-step generative modeling.

Before α-Flow, the landscape of from-scratch few-step methods was fragmented. Consistency models (Song et al., 2023), Shortcut Models (Frans et al., 2025), and MeanFlow (Geng et al., 2025a) were presented as distinct approaches with different loss functions, different training procedures, and different failure modes. Practitioners chose among them based on empirical benchmarks. The unification theorem reveals that these methods occupy different points on a single continuous curve: $\alpha = \delta$ with $r = 0$ and $z_0$-parameterization gives discrete CT; $\alpha = 0.5$ with bootstrapped shift velocity gives Shortcut Models; $\alpha \to 0$ with ground-truth shift velocity gives MeanFlow; $\alpha = 1$ gives pure flow matching. The "different methods" are not different at all—they are different settings of $\alpha$.

The intellectual payoff of this unification is that it enables traversal of the design space rather than selection of a point within it. The paper's curriculum strategy—annealing $\alpha$ from 1 to 0 during training—is the natural consequence of recognizing that each $\alpha$ value has distinct bias-variance properties and gradient characteristics, and that visiting them in sequence resolves the gradient conflict diagnosed in Innovation 1. This is fundamentally different from the mixture approach (75% $L_{\text{FM}'}$ + 25% $L_{\text{MF}}$) which tries to optimize multiple $\alpha$ regimes simultaneously and suffers gradient interference. The curriculum instead serializes the optimization, visiting $\alpha = 1$ first (low variance, supervised learning), then smoothly transitioning through intermediate $\alpha$ values (progressively introducing self-consistency), and finally reaching $\alpha \to 0$ (low bias for few-step generation).

This perspective also explains previously puzzling empirical phenomena. For instance, Shortcut Models only work well at $\alpha = 0.5$ because their bootstrapped shift velocity ($\tilde{v}_{s,t} = u_{\theta^-}(z_t, s, t)$) becomes unstable at smaller $\alpha$. MeanFlow's border-case $r = t$ supervision is necessary because jointly optimizing the $\alpha = 1$ and $\alpha \to 0$ regimes creates gradient conflict—a problem that the curriculum naturally avoids. The clamping value $\eta = 5 \times 10^{-3}$ marks the practical boundary where discrete $\alpha$ values degrade (Table 5c) and the continuous JVP-based MeanFlow objective becomes necessary, explaining why previous methods that tried only discrete or only continuous formulations left performance on the table.

Evidence anchor: Theorem 1 (proved in Appendix D.2) establishes the unification formally. Table 5(d) shows the progressive improvement as each component of the α-Flow design space is incorporated: Shortcut Model baseline (FID 59.8) → $\tilde{v}_{s,t} = v_t$ (59.2) → adaptive loss (49.7) → optimal $\alpha = 5 \times 10^{-3}$ (45.6), closing the gap with MeanFlow (43.3) through discrete α-tuning alone—before the curriculum is even applied.

Distinction from prior work: Frans et al. (2025) noted a conceptual connection between Shortcut Models and consistency training but did not formalize it as a unified parameterized family. The CTM framework (Kim et al., 2024) generalized consistency models to arbitrary $(t, r)$ pairs but did not connect to flow matching or MeanFlow. The UCGM paper (Sun et al., 2025) proposed a unified training scheme but through loss weighting, not through a continuous interpolation parameter. α-Flow's unification is more fundamental: it shows that the structure of the loss, not just the weighting, unifies the methods.

Is this incremental or fundamental? The individual pieces (sigmoid schedule for α, clamping at optimal discrete values) are incremental refinements. The unification perspective—that the entire design space collapses to a single parameter—is a fundamental conceptual shift. It transforms the practitioner's task from method selection to schedule design, which is a qualitatively different engineering problem with different optimization criteria.

Innovation 3: The Empirical Finding That Temporal Curriculum Resolves Gradient Conflict Better Than Loss Mixing

This innovation is the paper's primary empirical contribution: the demonstration that a curriculum strategy on α outperforms the joint optimization strategy (loss mixing) that MeanFlow and most prior methods used. This is not obvious a priori. One could reasonably argue that exposing the model to all α values simultaneously (via the $p(t, r)$ distribution in MeanFlow) would produce a more robust velocity field than sequential exposure—after all, multi-task learning often benefits from joint training. The paper's ablation (Table 2) shows the opposite: joint training with any fixed α or with MeanFlow's mixed objective is consistently worse than the curriculum.

The significance of this finding extends beyond MeanFlow. It provides evidence for a broader principle in generative model training: when objectives have antagonistic gradients, temporal decoupling via curriculum learning can be more effective than joint optimization with loss mixing, even when the mixing includes clever surrogate losses (like $L_{\text{FM}'}$) that partially mitigate the conflict. The paper shows this concretely: α-Flow with the curriculum achieves its best 1-NFE FID of 40.0 at only 25% $r = t$ ratio, while MeanFlow requires 75% to achieve a worse FID of 43.1 (Table 2b). The curriculum allows the model to spend more of its training budget on the objective of primary interest ($L_{\text{MF}}$) rather than on the surrogate ($L_{\text{FM}'}$) needed to stabilize joint optimization.

This is a negative result about joint optimization that carries positive implications. It suggests that the difficulty of training few-step generative models from scratch—which has been a persistent challenge since consistency models were introduced—may be primarily an optimization problem, not a capacity problem. The model architectures are sufficient (DiT backbones trained with α-Flow achieve strong results); what was insufficient was the optimization strategy for handling conflicting gradient signals. This reframes the research agenda: rather than designing larger models or more sophisticated consistency constraints, invest in better optimization strategies (curriculum learning, gradient projection, auxiliary objectives that reduce conflict).

The paper also provides a practical recipe for designing such curricula: identify the conflicting components (via gradient analysis), determine the natural parameter that interpolates between them (α), schedule that parameter from the low-variance regime to the low-bias regime, and use the schedule to reduce reliance on computational surrogates. This recipe is abstract enough to potentially transfer to other domains—for instance, training dynamics models with multi-step prediction horizons, or RL with value function and policy gradient conflict.

Evidence anchor: Table 2(a) shows that increasing pretraining duration ($k_s$ from 0K to 150K) monotonically improves 1-NFE FID from 44.4 to 41.3, and that longer transition durations with fixed midpoint produce the best results (0K→400K transition achieves FID 40.0 for NFE=1). Table 2(b) shows α-Flow achieves better FID with less $r = t$ supervision (FID 40.0 at 25% vs. MeanFlow's 43.1 at 75%).

Distinction from prior work: Geng et al. (2025b) used diffusion pretraining for consistency models, but their motivation was initialization quality, not gradient conflict resolution. They did not identify the loss as having antagonistic components, nor did they frame the pretraining as part of a curriculum that progressively introduces consistency. The α-Flow curriculum is directly motivated by the gradient conflict analysis, making it a principled response to a diagnosed problem rather than an empirical trick.

Is this incremental or fundamental? Incremental as a method (schedule design is a standard technique), but fundamental as a finding: it establishes that the loss landscape for few-step generative models has a structure (conflicting objectives with a natural interpolation parameter) that makes curriculum learning not just helpful but necessary for efficient optimization. The 75% computational waste in MeanFlow was the cost of ignoring this structure; α-Flow eliminates it.

5. Experimental Analysis

Evaluation Methodology

• Dataset. All experiments use the class-conditional ImageNet-1K dataset (Deng et al., 2009) at 256×256 resolution, comprising approximately 1.28 million training images across 1000 classes. Evaluation is performed on the standard 50,000-image validation set.

• Base model(s). The paper uses vanilla DiT architectures (Peebles & Xie, 2023) at two scales: DiT-B/2 (131M parameters, 12 layers, 768 hidden dimension, 12 heads) and DiT-XL/2 (676M parameters, 28 layers, 1152 hidden dimension, 16 heads). Both use patch size 2×2 and operate in the latent space of the Stable Diffusion VAE (sd-vae-ft-ema). An expanded DiT-XL/2+ variant is also used for fine-tuning experiments with a larger batch size of 1024. The paper explicitly notes that these models are "representative of the capabilities of many contemporary LLMs" (Section 4 in the original paper; here applied to image generation backbones), meaning the findings are not claimed to be architecture-specific but are demonstrated only on DiT.

• Metrics. The primary evaluation metrics are Fréchet Inception Distance (FID; Heusel et al., 2017) and Fréchet DINOv2 Distance (FDD; Oquab et al., 2023). FID measures distributional distance between generated and real images in Inception-v3 feature space—lower is better. FDD uses DINOv2 features, which correlate better with human perceptual judgment and are less sensitive to class-label distribution artifacts. For 1-NFE and 2-NFE generation, the paper reports both metrics. A critical detail: the standard FID protocol uses randomly sampled class labels (uniform from 0–999) for generating 50,000 samples, but the paper also reports a "balanced" variant (50 samples per class × 1000 classes) in Table 6, which yields up to ~10% lower FID but minimal FDD change—the paper argues this constitutes evidence that FDD and FCD are more robust metrics.

• Baselines. The paper compares against multiple from-scratch trained few-step methods: MeanFlow-XL/2 and MeanFlow-XL/2+ (Geng et al., 2025a)—the direct predecessor and primary comparison point; Shortcut-XL/2 (Frans et al., 2025)—a trajectory consistency method using bootstrapped shift velocities at α = 0.5; IMM-XL/2 (Zhou et al., 2025)—an inductive moment matching approach; and FACM-XL/2 (Peng et al., 2025)—flow-anchored consistency models. The paper also reproduces FACM-XL/2 at two training budgets (120×2 epochs and 240×2 epochs, where ×2 indicates FACM requires roughly twice the computation per epoch) for direct epoch-to-epoch comparison. For MeanFlow, the paper runs its own reproduction achieving 3.47 FID at 1-NFE for XL/2 trained 240 epochs, establishing a controlled comparison.

• Generation budget / compute accounting. The primary compute unit is the number of function evaluations (NFEs) during inference: 1 NFE for single-step generation and 2 NFEs for two-step generation. Training compute is measured in epochs (240 for main comparisons, with an additional 60 for fine-tuning runs) and matched across methods for fair comparison: α-Flow and MeanFlow use identical DiT architectures with 256 batch size for 1.2M training steps (approximately 240 ImageNet epochs). FACM's ×2 annotation in Table 1 indicates it performs two forward passes per training step, so "240 × 2 epochs" means equivalent computation to 480 epochs of standard training. The fine-tuning experiments for DiT-XL/2+ use 75K additional steps at batch size 1024 (equivalent to 60 epochs at batch size 256 in terms of samples seen, but with different gradient noise properties due to larger batches).

• Cross-validation / statistical protocol. No formal cross-validation is applied to the main results in Table 1—these are single training runs with fixed hyperparameters, which is standard practice for large-scale image generation benchmarks due to computational cost. However, the extensive ablation study on DiT-B/2 (Table 2) systematically sweeps schedule parameters ($k_s$, $k_e$), flow matching ratios, and discrete α values, with the best-performing configurations then transferred to the DiT-XL/2 scale. This constitutes an implicit validation protocol: hyperparameters are selected on the smaller model and evaluated on the larger one, providing evidence against overfitting to a specific scale. The paper does not report confidence intervals or multiple random seeds for the main results—a limitation acknowledged implicitly by the single-point FID/FDD reporting.

Main Quantitative Results

Comparison with Prior Few-Step Methods (Table 1)

The headline result is that α-Flow-XL/2 achieves 2.95 FID (164.6 FDD) at 1 NFE and 2.34 FID (105.7 FDD) at 2 NFE when trained for 240 epochs—a 15% relative improvement in 1-NFE FID over MeanFlow-XL/2 (3.47 FID) and a 70% improvement over FACM-XL/2 (9.54 FID when reproduced at 120×2 epochs; 6.59 FID at 240×2 epochs). The improvement is consistent across both metrics: FDD improves 12% over MeanFlow (164.6 vs. 185.8) and 60% over FACM at matched epochs (164.6 vs. 327.7 at 240×2).

When fine-tuned for an additional 60 epochs at batch size 1024, the largest α-Flow-XL/2+ model establishes what the paper claims as new state-of-the-art results among from-scratch trained models with vanilla DiT backbones: 2.58 FID (148.4 FDD) at 1 NFE and 2.15 FID (96.8 FDD) at 2 NFE. This surpasses MeanFlow-XL/2+ (which the paper also trains for the fine-tuning ablation in Table 4 at batch size 1024, achieving 3.06 FID at 1 NFE and 2.16 FID at 2 NFE) by 0.48 FID at 1 NFE while being marginally worse at 2-NFE FDD (96.8 vs. 93.4). Critically, α-Flow-XL/2+ also achieves 1.95 FID under balanced class sampling (Table 6), which the paper presents as competitive with FACM-XL/2's 2.07 FID (also under balanced sampling) while requiring only ~23% of the training epochs (240+60 = 300 total epochs equivalent vs. FACM's 800 + 250×2 epochs).

The epoch-matched comparison is crucial because FACM trains for substantially more epochs. The paper's reproduction of FACM at 240×2 epochs achieves only 6.59 FID, meaning the α-Flow advantage is not merely an artifact of longer training. However, FACM's published result (2.07 FID at 800+250×2 epochs) demonstrates that their method can eventually reach competitive quality with sufficient training, suggesting different methods have different convergence rates.

Scale consistency: The improvement holds at the smaller DiT-B/2 scale as well: α-Flow-B/2 achieves 5.40 FID (287.1 FDD) vs. MeanFlow-B/2's 6.04 FID (312.3 FDD) at 240 epochs—a ~10% relative improvement. This scale consistency (improvements at both 131M and 676M parameters) provides evidence that the α-Flow curriculum benefits are not limited to large models.

2-NFE performance: For two-step generation, α-Flow-XL/2 achieves 2.34 FID vs. MeanFlow-XL/2's 2.46 FID—a smaller but still meaningful improvement. The gap narrows for 2-NFE because MeanFlow already performs relatively well with multiple sampling steps; the curriculum primarily helps 1-NFE generation where the consistency objective matters most. α-Flow-XL/2+ further improves to 2.15 FID, establishing a new best result for from-scratch DiT-based 2-NFE generation.

FDD metrics: FDD improvements often exceed FID improvements proportionally. For example, α-Flow-XL/2 achieves 164.6 FDD vs. MeanFlow's 185.8 (12% improvement) while FID improves 15%. For α-Flow-XL/2+, FDD reaches 148.4 (1-NFE) and 96.8 (2-NFE), compared to MeanFlow-XL/2+'s 165.7 and 93.4. The paper argues FDD is more robust (less sensitive to class-label sampling artifacts, as shown in Table 6), so the FDD improvements provide independent validation that α-Flow's gains are not an artifact of FID's known weaknesses.

Ablation: Consistency Step Ratio Schedule (Table 2a)

This experiment on DiT-B/2 (400K training iterations, 25% flow matching ratio) systematically evaluates how the timing of the curriculum transition affects final performance.

Pretraining duration matters monotonically: Fixing the transition duration at 100K iterations and varying $k_s$ (the iteration at which α begins decreasing from 1), the paper finds monotonic improvement with longer pretraining:

• $k_s = 0$K (no pretraining, essentially MeanFlow): FID 44.4 (NFE=1), 42.1 (NFE=2)
• $k_s = 50$K: FID 44.1 (NFE=1), 39.9 (NFE=2)
• $k_s = 100$K: FID 42.4 (NFE=1), 38.3 (NFE=2)
• $k_s = 150$K: FID 41.3 (NFE=1), 38.1 (NFE=2)—best among fixed-duration configurations

The fact that $k_s = 150$K (pretraining for 37.5% of total iterations) outperforms $k_s = 0$K (Constant0.0, which is essentially MeanFlow) by ~3 FID points confirms that the trajectory flow matching pretraining phase is genuinely beneficial, not merely a neutral initialization. The monotonic improvement also suggests the optimal pretraining duration might be even longer than 150K iterations for this model size and budget—the paper did not test $k_s > 150$K with fixed transition duration.

Transition smoothness matters: Fixing the midpoint $(k_s + k_e)/2$ at 200K iterations and varying the total transition duration:

• 0K transition (instantaneous switch at 200K): FID 41.4 (NFE=1), 38.8 (NFE=2)
• 100K transition (150K→250K): FID 41.3 (NFE=1), 38.1 (NFE=2)
• 400K transition (0K→400K, no pretraining, gradual from start): FID 40.0 (NFE=1), 37.1 (NFE=2)—best overall

The 400K transition (Sigmoid0K→400K) outperforms the 100K transition despite having no dedicated pretraining phase—this suggests that a very gradual transition can substitute for explicit pretraining to some degree, likely because the early iterations with α close to 1 effectively serve as flow matching pretraining. However, this configuration cannot benefit from the "front-loading" strategy of pure flow matching before introducing consistency. The fact that the 400K transition performs best at 1-NFE but the paper ultimately uses $k_s > 0$ for larger models (Table 3: $k_s = 600$K for XL/2) suggests an interaction with model scale: larger models may benefit more from dedicated pretraining because they have more capacity to establish a high-quality velocity field before the consistency objective is introduced.

Convergence vs. final performance tradeoff: The Sigmoid150K→250K configuration (41.3 FID) underperforms Sigmoid0K→400K (40.0 FID) at 400K iterations, but with only 400K total iterations, the model with pretraining may not have sufficient time in the MeanFlow fine-tuning phase to fully converge. The paper's transfer of $k_s = 600$K to XL/2 (out of 1.2M total steps)—giving 50% pretraining, 33% transition, and 17% fine-tuning—suggests that at scale, dedicating more iterations to pretraining pays off in final quality.

Ablation: Flow Matching Ratio (Table 2b)

This experiment directly tests the paper's claim that α-Flow reduces reliance on border-case flow matching supervision ($L_{\text{FM}'}$, the $r = t$ samples). For DiT-B/2 at 400K iterations, comparing the Constant0.0 schedule (pure MeanFlow with no curriculum) against Sigmoid0K→400K (full curriculum from start) at four different $r = t$ ratios: 0%, 25%, 50%, 75%.

α-Flow consistently outperforms MeanFlow at every ratio. At 25% $r = t$—the optimal for α-Flow's 1-NFE—α-Flow achieves FID 40.0 vs. MeanFlow's 44.4, a ~10% relative improvement. At 75%—the optimal for MeanFlow—α-Flow achieves 42.2 vs. 43.1, still better but with a smaller gap. The fact that α-Flow at 25% (FID 40.0) outperforms MeanFlow at 75% (FID 43.1) while using one-third the flow matching budget directly supports the efficiency claim.

Tradeoff between 1-NFE and 2-NFE emerges: For α-Flow with the curriculum, 1-NFE performance peaks at 25% $r = t$ (FID 40.0) and degrades at 75% (FID 42.2). In contrast, 2-NFE performance improves with higher $r = t$ ratios: 25% yields 38.9 FID, 50% yields 37.1, 75% yields 36.2. This reveals a bias-variance tradeoff: more flow matching supervision improves the model's velocity field accuracy (benefiting multi-step generation where ODE integration matters) at the cost of one-step consistency quality. The paper's choice of 25% for B/2 and 50% for XL/2 (Table 3) reflects a prioritization of 1-NFE performance for B/2 and a balance for XL/2.

Why does α-Flow not need as much $L_{\text{FM}'}$? The pretraining phase (α = 1) already optimizes the full $L_{\text{TFM}}$ objective, which provides stronger velocity field supervision than $L_{\text{FM}'}$ (since $L_{\text{TFM}}$ covers all $r \leq t$, not just $r = t$). By the time the curriculum reaches α ≈ 0 (MeanFlow phase), the model's velocity field is already well-established from pretraining, reducing the need for ongoing $L_{\text{FM}'}$ correction. This directly validates the paper's central hypothesis from Section 3: the border-case supervision in MeanFlow compensates for the gradient conflict between $L_{\text{TFM}}$ and $L_{\text{TCc}}$; by resolving the conflict through temporal decoupling, α-Flow makes much of this supervision unnecessary.

Interaction with schedule: For Constant0.0 (no curriculum), the 1-NFE FID improves from 46.0 at 0% to 43.1 at 75%, confirming MeanFlow's reported dependence on border-case supervision. For Sigmoid0K→400K, the dependence is much weaker (40.4 to 40.0 to 42.2), with near-optimal performance achievable at 0% or 25%. This suggests the curriculum provides a robust alternative to heavy $L_{\text{FM}'}$ reliance across a wide range of ratios.

Comparison of Sampling Methods (Figure 4)

The paper compares ODE sampling and consistency sampling for 2-NFE generation across different intermediate timestep choices, using MeanFlow-XL/2, α-Flow-XL/2, and α-Flow-XL/2+.

Consistency sampling benefits α-Flow more than MeanFlow. For α-Flow-XL/2, consistency sampling (dotted line) achieves best FID of approximately 2.09 at intermediate timestep 0.4, compared to ODE sampling's (solid line) best of approximately 2.32 at timestep 0.35. For α-Flow-XL/2+, consistency sampling reaches approximately 2.28 at timestep 0.45. In contrast, MeanFlow-XL/2 shows the opposite pattern: ODE sampling achieves best FID of approximately 2.39 at timestep 0.35, outperforming its own consistency sampling.

Interpretation: The paper hypothesizes that consistency sampling relies more heavily on the model's ability to make accurate large jumps (specifically to $r = 0$), which requires the trajectory consistency component ($L_{\text{TCc}}$) to be well-optimized. The α-Flow curriculum, by resolving the gradient conflict against $L_{\text{TFM}}$, produces better-optimized trajectory consistency, which manifests as improved consistency sampling performance. MeanFlow's joint optimization may compromise the quality of the $r = 0$ prediction specifically (since $L_{\text{TFM}}$ and $L_{\text{TCc}}$ conflict most strongly at small $r$ where $(t-r)$ is large), making ODE integration—which uses intermediate velocity predictions rather than direct data mapping—more reliable.

Intermediate timestep sensitivity: The optimal intermediate timestep for ODE sampling is consistently around 0.35–0.5 across all models, matching the common practice in diffusion model literature. For consistency sampling, α-Flow-XL/2 shows a clear optimum at 0.4, while α-Flow-XL/2+ peaks at 0.45—the shift toward higher midpoints with better convergence might indicate that stronger models prefer larger initial jumps (more denoising in the first step). The paper selects final intermediate timesteps of 0.55 for α-Flow-XL/2 and 0.5 for α-Flow-XL/2+ (Table 3) by balancing FID and FDD, not just optimizing FID alone.

Fine-Tuning Batch Size Ablation (Table 4)

This experiment fine-tunes a pre-trained MeanFlow-XL/2 model (240 epochs at batch size 256) for an additional 60 epochs at batch sizes 256, 512, 1024, 2048, and 4096. The goal is to determine whether larger batches—which reduce gradient variance, a known issue in consistency training—improve final performance.

The optimal batch size is 1024: At 1 NFE, batch size 512 achieves best FID of 3.05 but batch size 1024 achieves best FDD of 165.7 (vs. 167.2, 164.3, 169.6, 168.9 for other sizes). At 2 NFE, batch size 1024 achieves 2.16 FID and 93.4 FDD, while batch size 2048 achieves slightly better 2-NFE FID of 2.10 but worse FDD of 96.6. The paper designates batch size 1024 as the XL/2+ configuration based on balanced performance. This is consistent with prior findings in diffusion model training (Karras et al., 2024; Zhou et al., 2025) that larger batches stabilize consistency training, but with diminishing returns beyond 1024.

Diminishing returns and potential degradation: Batch size 4096 shows worse performance (3.13 FID, 168.9 FDD at 1 NFE) than 1024, suggesting that extremely large batches may cause optimization difficulties—possibly related to the sharpness of the loss landscape or reduced stochasticity beneficial for escaping poor local minima. The paper acknowledges in Appendix B that the observed improvements "may instead reflect that small batches are more sensitive to hyperparameters (Marek et al., 2025), and that beyond a certain size, batch-size scaling exhibits diminishing returns (McCandlish et al., 2018)."

Ablation Studies and Robustness Checks

Training objective design space (Table 5a): For α-Flow with α = 10⁻² (discrete regime), the choice of shift velocity $\tilde{v}_{s,t}$ and whether to use EMA for $u_{\theta^-}$ dramatically affects convergence. Using $\tilde{v}_{s,t} = v_t$ (ground-truth velocity) with no EMA achieves FID 59.2, while using $\tilde{v}_{s,t} = u_{\theta^-}$ (bootstrapped, as in Shortcut Models) produces FID 319.0—essentially non-convergent. EMA helps slightly with bootstrapping (188.1 FID) but hurts with ground-truth velocity (202.8). This is a strong negative result: the bootstrapping approach that works for Shortcut Models at α = 0.5 fails catastrophically at smaller α, suggesting the self-bootstrapping target becomes too noisy when the consistency step is small. The finding justifies α-Flow's design choice to use $\tilde{v}_{s,t} = v_t$ without EMA, which is both simpler and more effective.

Adaptive loss weight formulation (Table 5b): The paper's derived α-scaled adaptive weight $\omega = \alpha / (\|\Delta\|_2^2 + c)$ empirically outperforms alternatives: FID 49.7 vs. 52.2 for the standard MeanFlow weight and 59.2 for no adaptive weighting. The square-root variant $\omega = 1/(\|\Delta\|_2^2 + c)^{0.5}$ achieves intermediate performance (55.0), suggesting the optimal scaling is close to linear in $1/\|\Delta\|_2^2$. The α-dependent scaling provides about 5% additional improvement over the standard adaptive weight, confirming that accounting for the α-dependent loss magnitude is practically beneficial.

Optimal fixed α for discrete α-Flow (Table 5c): Training with a constant α (no curriculum) reveals a U-shaped performance curve: α = 5 × 10⁻³ achieves best FID of 46.2, while α = 10⁻² (49.7), α = 2 × 10⁻³ (50.3), and α = 10⁻³ (57.2) all perform worse. This establishes the clamping value η = 5 × 10⁻³ used in the curriculum schedule and explains why simply training with a single small α is insufficient—the optimal discrete α achieves only 46.2 FID vs. MeanFlow's 43.3, motivating the curriculum approach that uses discrete α during transition but ultimately fine-tunes at α → 0.

Incremental improvement accumulation (Table 5d): Building up from a Shortcut Model baseline (FID 59.8, FDD 1017.3), the table shows how each α-Flow design choice contributes: switching to $\tilde{v}_{s,t} = v_t$ gives 59.2 FID; adding adaptive loss improves to 49.7; optimizing α to 5 × 10⁻³ reaches 45.6; MeanFlow (the α → 0 limit) achieves 43.3. This demonstrates that no single change accounts for the full improvement—each component (ground-truth shift velocity, adaptive weighting, small α) contributes meaningfully, and the residual gap to MeanFlow (43.3 vs. 45.6) motivates the full curriculum that eventually reaches the continuous limit.

Classifier-free guidance configuration (Table 3): The paper adopts MeanFlow's CFG settings with training-time guidance parameters w = 0.2 and κ = 0.92, triggered only for t ∈ [0.0, 0.75] and without EMA for the CFG predictions. The restricted time range prevents the model from over-relying on guidance in the high-noise regime where class information is unreliable. No ablation over these values is reported for α-Flow, meaning the paper inherits these hyperparameters from MeanFlow without verifying they remain optimal for the α-Flow curriculum. This is a gap—it is plausible that the curriculum strategy changes the optimal CFG configuration.

DiT-B/2-non-cfg analysis model: The gradient analysis in Section 3 and the detailed ablations in Table 5 use a DiT-B/2 variant without classifier-free guidance (noted in Table 3 as DiT-B/2-non-cfg). This is an important detail: the gradient conflict findings and discrete α-Flow ablations are established in the simpler unconditional setting before being transferred to the CFG setting. The paper does not explicitly verify that the gradient conflict patterns hold identically with CFG training, though the strong performance of α-Flow with CFG (Table 1) suggests the curriculum benefits transfer.

Negative results from Appendix C: The paper documents several unsuccessful experiments: attempting decomposed training of the MeanFlow objective with individually tuned loss weights (inspired by EDM's design space exploration) consistently produced worse results than the default adaptive loss heuristic; LoRA fine-tuning and separate prediction heads for vanilla velocity vs. mean velocity did not yield improvements; roughly 50 ablations on the train-time noise schedule for vanilla MeanFlow—including factorizing p(t, r) into p(t)p(r|t)—failed to outperform the default logit-normal distribution with location parameter −0.4; representation alignment losses (Yu et al., 2025) intended to accelerate convergence provided insufficient gains to justify added complexity; and different EMA schedules showed no meaningful impact. These negative results are valuable for the community because they indicate that the optimization conflict identified in Section 3 is not easily resolved through loss reweighting, architecture changes, or noise schedule tuning—the curriculum strategy appears to be the first intervention that reliably addresses the fundamental gradient interference problem.

Critical Assessment

Claim from executive summary: "α-Flow consistently outperforms MeanFlow across scales and settings." This claim is well-supported for the tested configurations (DiT-B/2 and DiT-XL/2 at 240 epochs; DiT-XL/2+ at 240+60 epochs). Table 1 shows consistent improvements at both model scales and for both 1-NFE and 2-NFE generation. The improvement holds across different flow matching ratios (Table 2b) and schedule configurations (Table 2a). However, "across scales" is demonstrated only at two scales (131M and 676M parameters)—there is no evidence at smaller scales (e.g., DiT-S) or larger scales (beyond 676M). The claim also cannot be verified for training budgets beyond 240 epochs on the main models, since the compared baselines (except MeanFlow-XL/2+ at 240+60 epochs) are not trained longer. FACM's reported result at 800+250×2 epochs raises the question: would MeanFlow trained for 800 epochs catch up to or surpass α-Flow at 300 epochs? The paper cannot answer this because it doesn't run the long-training baselines due to computational constraints.

Claim: "Our largest α-Flow-XL/2+ model achieves new state-of-the-art results using vanilla DiT backbones." This claim requires careful qualification. It holds for the specific constraint "vanilla DiT backbones" and "trained from scratch" on ImageNet-1K 256×256. Table 1 shows 2.58 FID (1-NFE) and 2.15 FID (2-NFE) with random class sampling, and 1.95 FID (2-NFE) with balanced class sampling. This surpasses MeanFlow-XL/2+ (3.06/2.16), but Appendix I and Table 6 reveal a nuance: the 1.95 FID with balanced sampling is competitive with FACM-XL/2's reported 2.07 FID under the same balanced protocol, and α-Flow achieves this at a fraction of the training epochs. However, the paper does not train α-Flow for 800+250×2 epochs, so it cannot claim definitive superiority over FACM at convergence—only at matched or lower training budgets.

Furthermore, "state-of-the-art" applies only within the paper's self-defined scope. Methods using improved architectures (e.g., REPA-aligned training from Yu et al., 2025), distillation from pre-trained models (Sauer et al., 2024; Yin et al., 2024a), or larger VAEs might achieve better results but fall outside the "vanilla DiT, from-scratch" constraint. This is not a weakness of the paper's contributions, but the claim's scope should be understood precisely.

Claim: "the curriculum strategy disentangles the conflicting objectives and reduces reliance on border-case flow matching supervision." The evidence for disentanglement is indirect but convincing. Table 2b shows that α-Flow achieves its best 1-NFE performance at 25% r = t ratio vs. MeanFlow's 75%, and α-Flow at 25% (FID 40.0) substantially outperforms MeanFlow at 75% (FID 43.1). This demonstrates reduced reliance on border-case supervision. The claim that this reduction is caused by disentanglement of conflicting objectives (rather than some other effect of the curriculum) rests on the gradient analysis in Figure 2a—which shows the conflict exists—and the logical connection that temporal decoupling resolves it. However, the paper does not directly measure gradient conflict during the α-Flow curriculum and show it is reduced compared to MeanFlow training. Such an experiment (compute $\cos(\nabla L_{\text{TFM}}, \nabla L_{\text{TCc}})$ during the α-Flow transition phase) would strengthen the mechanistic claim. Without it, the reduced reliance on $L_{\text{FM}'}$ could potentially be explained by other factors, such as the flow matching pretraining simply providing a better initialization that makes the consistency loss easier to optimize regardless of gradient conflict.

Weakness: single dataset and architecture family. All experiments use ImageNet-1K 256×256 with DiT backbones. The paper does not evaluate on other image generation benchmarks (e.g., CIFAR-10, LSUN, FFHQ) or other modalities. The transfer of hyperparameters from B/2 to XL/2 suggests some robustness to model scale, but the findings might not generalize to substantially different architectures (e.g., UNet-based diffusion backbones, or the MDT architecture). The paper acknowledges this implicitly by not claiming generality beyond DiT, but a single-dataset evaluation is a genuine limitation for a method paper.

Weakness: difficulty estimation cost is unaccounted for in the training budget. While this paper doesn't use "difficulty estimation" in the sense of the MeanFlow/LLM paper, there is an analogous issue: the gradient analysis that motivates α-Flow required extensive instrumentation and hyperparameter sweeps that produced Tables 2, 5, and the failed experiments in Appendix C. The final α-Flow method works well, but the paper does not quantify how many GPU-hours of ablation were required to arrive at the optimal schedule parameters ($k_s = 600$K for XL/2, $\eta = 5 \times 10^{-3}$, 25–50% $r = t$ ratio, etc.). For practitioners wanting to apply α-Flow to new domains, the paper provides a starting point but not a recipe for deriving schedule parameters without similar sweeps. The sigmoid schedule has four parameters ($k_s$, $k_e$, $\gamma$, $\eta$); the paper explores $k_s$, $k_e$, and $\eta$ systematically but fixes $\gamma = 25$ without ablation. It is possible that $\gamma$ is important and the default value is suboptimal for other settings.

Weakness: no combination with other improvements. The paper studies α-Flow in isolation but does not combine it with other known techniques for improving diffusion model training—REPA alignment (Yu et al., 2025), improved VAE architectures, or the EDM2 training improvements (Karras et al., 2024). The "vanilla DiT" constraint is useful for isolating the effect of the α-Flow loss, but it leaves open the question of whether α-Flow's benefits are additive with other improvements or whether the curriculum strategy would interfere with them. For instance, representation alignment losses add gradient terms that might interact with the α-Flow curriculum dynamics in unpredictable ways.

Weakness: lack of statistical reporting. All main results are single-run FID/FDD numbers without error bars, confidence intervals, or multiple seeds. Given the known variability in FID measurements (differences of 0.1–0.2 FID can arise from random seed alone), the reported improvements of 0.01–0.5 FID in some comparisons (e.g., the fine-tuning batch size ablation in Table 4) may be within noise. The larger improvements (0.52 FID at B/2 scale, 0.52 FID at XL/2 scale for 1-NFE) are substantial enough to likely exceed seed variance, but this is not quantified. FDD, being less sensitive to class sampling, shows proportionally similar improvements, lending credibility.

Missing experiment: measuring gradient conflict during the curriculum. The paper's core mechanistic claim—that the curriculum disentangles the conflicting objectives—would be strengthened by an experiment analogous to Figure 2a but conducted during α-Flow training. Does $\cos(\nabla L_{\text{TFM}}, \nabla L_{\text{TCc}})$ remain negative during the transition phase, or does the sequential optimization change the loss landscape geometry? During the MeanFlow fine-tuning phase (α → 0), is the gradient conflict still present, and if so, why does it not cause the same convergence issues as in vanilla MeanFlow training? The paper argues this is because the model is already near the $L_{\text{TFM}}$ optimum, making the conflict less damaging, but this is a hypothesis, not a demonstrated fact.

Missing experiment: varying γ (sigmoid temperature). The temperature parameter γ controls the sharpness of the α transition. All experiments use γ = 25, but no ablation is reported. A sharper transition (larger γ) would more closely approximate the two-phase "pretrain then MeanFlow" strategy that the paper's analysis might suggest; a smoother transition (smaller γ) would behave more like the Sigmoid0K→400K configuration. Understanding whether the exact transition shape matters—or whether a simple linear or step-function schedule would work equally well—would clarify how sensitive the method is to this hyperparameter.

The balanced vs. random class sampling issue (Table 6, Appendix I). This deserves scrutiny. The paper reports that balanced class sampling produces up to ~10% lower FID while barely affecting FDD and FCD, and advocates for the community to switch to FDD/FCD as more robust metrics. However, the paper then cites its balanced-sampling FID result (1.95) in the abstract-level claim about state-of-the-art performance, while the main Table 1 reports random-sampling FID. This dual reporting could confuse readers about which numbers to compare against prior work (which universally use random sampling). The paper is transparent about this in Appendix I, but the practice of reporting the lower balanced-sampling number prominently in Section 5.1 ("surpasses FACM-XL/2's 2.07 FID ... by reaching 1.95 FID") while the main table uses random sampling creates a rhetorical asymmetry: the best possible α-Flow number is compared against the published FACM number, even though the evaluation protocols differ.

Overall assessment: The experiments provide strong evidence for the paper's primary claims about α-Flow's empirical performance: it consistently and meaningfully improves over MeanFlow at matched compute budgets, reduces reliance on border-case flow matching supervision, and achieves state-of-the-art results within its defined scope. The mechanistic claims about gradient conflict are well-supported by the analysis in Section 3, but the connection between that analysis and the curriculum's effectiveness—while theoretically coherent—is not experimentally closed-loop. The paper would be strengthened by experiments directly measuring gradient dynamics during the curriculum, by multi-seed evaluations with confidence intervals, and by testing on additional datasets or architectures. The extensive ablation study and honest reporting of failed experiments (Appendix C) partially offset these limitations by demonstrating rigorous empirical investigation of the design space.

6. Limitations and Trade-offs

DiT Architecture and ImageNet as Sole Evaluation Domain

The assumption or constraint. Every experiment in the paper—the gradient analysis in Section 3, the full design space ablation in Table 5, the curriculum schedule sweep in Table 2, and the main results in Table 1—uses DiT backbones (Peebles & Xie, 2023) trained on class-conditional ImageNet-1K at 256×256 resolution. There is no evaluation on other architectures (e.g., UNet-based diffusion backbones such as those in EDM2, or the MDT family), other image datasets (CIFAR-10, LSUN, FFHQ, MS-COCO), other modalities (audio, video, text), or other generative modeling frameworks (score-based SDE models rather than flow matching). The paper does not claim generality, but it also does not acknowledge this as a limitation in the main text or Appendix B (Limitations).

The consequence. A practitioner wanting to use α-Flow on a UNet-based latent diffusion model, or on a text-to-image generation task with a different latent space, or on a smaller dataset with different training dynamics, has no evidence that the gradient conflict pattern observed in Figure 2a or the optimal schedule parameters from Table 2 transfer. Several aspects of the α-Flow design could be architecture- or dataset-dependent: the cosine similarity between $\nabla L_{\text{TFM}}$ and $\nabla L_{\text{TCc}}$ (measured at approximately −0.4 throughout training for DiT-B/2 on ImageNet) might differ for architectures with different inductive biases or different data distributions. The optimal clamping value $\eta = 5 \times 10^{-3}$ was determined empirically on DiT-B/2 (Table 5c) and might not be optimal for other architectures. The sigmoid temperature $\gamma = 25$ was fixed for all experiments without ablation, and its suitability for other settings is unknown. The logit-normal distribution with location parameter −0.4 used for sampling $(t, r)$ pairs is inherited from MeanFlow without testing alternatives (Appendix C documents roughly 50 failed ablations on noise schedules for vanilla MeanFlow, suggesting this distribution is important and non-trivial to tune).