ArcFlow: Unleashing 2-Step Text-to-Image Generation via High-Precision Non-Linear Flow Distillation

ArXiv: 2602.09014

🎯 Pitch

Two-step image generators routinely collapse quality because they force a curved teacher trajectory into straight-line segments—ArcFlow fixes this by modeling velocity as a mixture of momentum processes that evolve mid-step, yielding an exact analytic solution that eliminates discretization errors. The result is a 40× speedup on 20B-parameter models while fine-tuning under 5% of weights, matching or exceeding fully trained few-step baselines with no adversarial loss.

1. Executive Summary

ArcFlow introduces a few-step distillation framework that explicitly constructs non-linear flow trajectories to approximate the complex dynamics of pre-trained diffusion teachers, addressing the geometric mismatch that arises when existing methods force linear shortcuts onto constantly varying tangent directions. Built on large-scale text-to-image models (Qwen-Image-20B and FLUX.1-dev), ArcFlow parameterizes the velocity field as a mixture of continuous momentum processes (decomposing the velocity into K distinct modes, each with its own learnable velocity, momentum factor, and gating probability), which admits a closed-form analytic solver that integrates the non-linear trajectory exactly without numerical discretization errors. Evaluated on Geneval, DPG-Bench, OneIG-Bench, and Align5000, ArcFlow achieves a 40× inference speedup with only 2 NFEs over the original multi-step teachers while fine-tuning less than 5% of parameters (using only rank-256 LoRA adapters and output head), surpassing competing 2-step methods like pi-Flow and TwinFlow on both image quality and distributional fidelity metrics. The method demonstrates that respecting the underlying non-linear flow dynamics enables high-precision teacher alignment without adversarial objectives or full-model retraining, establishing that parameter-efficient distillation can match or exceed fully-trained few-step baselines only when the student's trajectory parameterization is geometrically compatible with the teacher's velocity evolution.

2. Context and Motivation

The Core Problem: Linear Shortcuts Cannot Approximate Non-Linear Trajectories

The fundamental problem ArcFlow addresses is a geometric mismatch in few-step distillation of diffusion and flow matching models. Pre-trained multi-step teachers navigate the probability flow ODE [27] along trajectories whose tangent directions (the instantaneous velocities) constantly change as the denoising process unfolds across 40–100 timesteps. When distilling this process into 2–4 steps, existing methods implicitly force the student model to approximate this entire trajectory using linear steps — straight-line segments connecting sparse waypoints. The paper argues this is fundamentally wrong: a linear segment cannot capture the curvature of the teacher's path.

To understand why this matters geometrically, consider what a student with 2 NFEs must do. The teacher takes, say, 50 steps from noise to data. Each step predicts a velocity v(x_t, t) that points in a slightly different direction than the previous step. The accumulated path is a smooth curve. A 2-step student must travel the entire path from t=1 to t=0 using only two velocity evaluations. If the student assumes the velocity is constant within each half-interval (the linear assumption), it produces two straight-line segments. But the teacher's path within each half-interval is curved — its tangent changes. The linear approximation forces the student to learn a single velocity direction that somehow compensates for all the tangent variation within that interval. As the paper states in Section 1:

"their essence still lies in approximating the trajectory from the teacher generation process (40 ~ 100 steps), whose tangent directions vary over multiple timesteps, via a linear shortcut under very few steps (2 ~ 4 steps). This enforces the students to implicitly learn such tangent variation with linear trajectories, leading to geometric mismatch."

This is the central insight. It's not just that linear shortcuts are approximate — it's that the approximation is structurally inadequate. A linear model has zero curvature; the teacher's trajectory has non-zero curvature. The student must use its limited capacity (the model weights) to "swallow" this curvature into a single velocity prediction per step, which causes the student to deviate from the teacher's distribution and lose fidelity.

Why This Problem Matters: The 40–100x Inference Bottleneck

The practical stakes are enormous. Diffusion and flow matching models — including recent large-scale text-to-image systems like FLUX [17,18] and Qwen-Image [37] — produce state-of-the-art image quality but require 40–100 sequential neural function evaluations (NFEs) per image. At 1024×1024 resolution on a 20B-parameter model, this translates to seconds of wall-clock time per generated image, making these models impractical for real-time applications, interactive creative tools, or deployment in resource-constrained settings.

The paper quantifies this as a $40\times$ speedup target (Section 4). Achieving this with only 2 NFEs — while preserving generation quality comparable to the 50-step teacher — is the concrete engineering goal. But the paper's deeper significance is theoretical: it challenges the assumption, implicit in most distillation work, that the problem is merely one of "compressing" many teacher steps into fewer student steps. ArcFlow argues that compression alone is insufficient — what matters is whether the student's trajectory space can represent the teacher's trajectory shape. If the student's parameterization is structurally incapable of producing curves (because it only allows piecewise-linear paths), then no amount of training data or loss optimization can perfectly match the teacher. The geometric mismatch is a representational bottleneck, not just an optimization bottleneck.

This reframes the problem from "how do we train a student to predict good linear steps?" to "how do we give the student a parameterization that can natively express non-linear trajectories?" ArcFlow's answer — momentum-based velocity mixtures with analytic integration — is a solution to this more fundamental question.

Prior Approaches and Where They Fall Short

The paper identifies four families of distillation methods, each with limitations that the geometric mismatch perspective helps explain.

Progressive Distillation and Rectified Flow [21, 23, 25]: These methods iteratively train a student to match two teacher steps with one student step, halving the total NFEs each round. After enough rounds, the path from noise to data becomes a small number of longer steps. The core assumption is that the teacher's trajectory can be straightened — that by repeatedly forcing the student to take larger leaps, the path becomes approximately linear. However, as the paper notes, these methods "struggle to eliminate discretization errors in the few-step regime" (Section 2). The reason becomes clear from the ArcFlow perspective: straightening is an approximation that works reasonably well when reducing from 100 to 8 steps, but breaks down at 2–4 steps where the residual curvature is too large to ignore. The student is being asked to reconcile contradictory velocity directions that span a large portion of the trajectory.

Consistency Models [22, 28]: These approach the problem differently — instead of matching velocities, they train the student to map any point on the trajectory directly to the data endpoint x_0. The loss enforces that two points on the same trajectory should map to the same output (self-consistency). This avoids the linear-step assumption entirely, but introduces other difficulties. The paper notes they "often require computationally expensive Jacobian-vector product calculations to maintain convergence stability" [11]. More subtly, consistency models must learn to jump from any intermediate state to the endpoint, which is a harder learning problem than modeling local transitions — the student must implicitly encode the entire remaining trajectory in a single mapping, without the benefit of intermediate curvature information.

Adversarial and Distribution Matching Methods [7, 26, 36, 39]: Techniques like VSD (Variational Score Distillation), DMD (Distribution Matching Distillation), and TwinFlow use discriminator networks or adversarial objectives to push the student's output distribution toward the teacher's. These methods can produce sharp, visually appealing images because the discriminator penalizes blurriness directly. However, the paper identifies two critical weaknesses. First, adversarial training is unstable and can lead to mode collapse — the student learns to produce a narrow range of images that fool the discriminator rather than matching the teacher's full diversity (Section 2, confirmed quantitatively in Table 1: Qwen-Image-Lightning shows substantially lower Diversity on OneIG-Bench). Second, these methods require full-parameter fine-tuning of large models, which is computationally expensive and can override the teacher's pre-trained priors (Section 3.3), requiring the student to re-learn features from scratch rather than adapting the teacher's knowledge.

Gaussian Mixture Approximations [4, 5]: pi-Flow and Gaussian Mixture Flow Matching (GM-FM) represent the closest prior work to ArcFlow. They also recognize that velocity evolution across timesteps is non-trivial and attempt to approximate it using mixtures of Gaussian components in probability space. However, the paper argues these "probabilistic approximations lack precision at lower NFEs (2 steps)" (Section 2). The key distinction is that ArcFlow operates on the velocity field directly through a deterministic exponential parameterization, which admits an exact analytic integral, while Gaussian mixture approaches approximate the probability path statistically through policy-based imitation, which introduces sampling error and approximation noise that compound at very low step counts.

How ArcFlow Positions Itself

ArcFlow's positioning is defined by what it claims to be the first to do: explicitly construct non-linear flow trajectories for few-step distillation. The paper states this directly in the contributions (Section 1):

"We propose ArcFlow, the first distillation framework to explicitly construct a non-linear flow trajectory to approximate the teacher trajectory."

The word "explicitly" is doing important work here. Prior methods either (a) use linear steps and hope the model learns to compensate for curvature implicitly, (b) jump directly to endpoints bypassing intermediate geometry, or (c) match distributions without modeling trajectories at all. ArcFlow instead gives the student a parameterization that can natively represent curves — the momentum mixture (Eq. 2) — and then analytically integrates that curve to compute exact state transitions.

This positioning explains three design choices that distinguish ArcFlow from competitors:

1. Velocity parameterization, not distribution matching. ArcFlow operates in the velocity space, aligning the student's predicted velocity field with the teacher's at sparse checkpoints (Eq. 7). This is fundamentally a trajectory-level objective: even though the loss is computed at individual timesteps, the parameterization enforces that velocities across timesteps are coupled through the exponential momentum law (Eq. 1). In contrast, DMD and TwinFlow operate in the image distribution space, which loses the sequential structure of the denoising process.

2. Analytic integration, not numerical discretization. Because the momentum parameterization produces velocities of the form v(t) = v(t_s) · γ^(t_s - t), the integral over any interval can be computed exactly via Eq. (4–5). Standard distillation (including pi-Flow's Euler-based step approximation) must accumulate discrete velocity samples, introducing discretization error. ArcFlow pays this integration cost analytically in O(1) time per step, regardless of the interval length. The paper calls this "high-precision approximation" — it means that even though the student only evaluates its network at sparse timesteps, the transition between those timesteps is computed exactly according to the assumed dynamics, not approximated by a straight line.

3. Parameter-efficient adaptation, not full retraining. Because the momentum parameterization is geometrically compatible with the teacher's trajectory — it can represent the curvature that linear methods lack — the student does not need to override the teacher's internal features to compensate for structural mismatch. This is the argument in Section 3.3: "Linear methods force the student to override the teacher's priors to fit linear rectification, which requires invasive full-parameter finetuning." ArcFlow only needs to learn when and how much to curve (via the momentum factors γ_k), what base directions to curve from (via v_k), and how to mix these modes (via π_k). This is a much lighter adaptation task, achievable with LoRA adapters and a new output head (Table 6: rank-256 LoRA on < 5% of parameters). The result is 4× faster training convergence (Figure 2) with lower memory requirements.

The implicit claim about geometric compatibility. Throughout the paper, there's an unstated but crucial argument: the difficulty of distillation — how much training data is needed, how many parameters must be updated, how unstable the optimization is — is not just a function of the model architecture or loss function. It is fundamentally determined by whether the student's hypothesis space (the set of trajectories it can represent) contains or intersects the teacher's reference trajectory. If the student can only represent linear paths, it must climb out of a deep valley in parameter space to approximate a curve with a straight line, which requires large parameter updates and risks instability. If the student can natively represent curves, the teacher's trajectory is already near a good local optimum, and only minor adaptation is needed. This is the paper's theoretical contribution that underpins all the practical benefits (speed, stability, parameter efficiency).

Relationship to the Momentum Concept

The paper draws an explicit analogy to classical mechanics: momentum in physics describes how an object's velocity evolves over time under the influence of forces, with the momentum factor determining how quickly velocity changes. In ArcFlow, the velocity at time t is predicted not in isolation but as a decayed version of the velocity at an earlier reference time t_s, following v(t) = v(t_s) · γ^(t_s - t). When γ < 1, the velocity decays (decelerating mode — the trajectory is "slowing down" toward the data distribution). When γ > 1, the velocity grows (accelerating mode — the trajectory is "speeding up" as it moves away from noise). When γ = 1, the velocity is constant, recovering the linear regime as a special case.

This formulation captures the intuition that denoising dynamics have temporal structure: adjacent timesteps are not independent. The velocity at t = 0.8 is related to the velocity at t = 0.9 by some systematic evolution, not an arbitrary change. The Euler method discards this structure by treating each step independently; ArcFlow exploits it by making it an explicit part of the model.

The mixture-of-momentum-modes extension (K components in Eq. 2) addresses the fact that different "aspects" of the image evolve at different rates. The paper cites empirical studies [8] showing that "different frequency components evolve at distinct rates during denoising" — high-frequency details appear later and change faster, while low-frequency structure appears earlier and changes more slowly. A single γ cannot capture this heterogeneity. The mixture allows each mode k to have its own velocity v_k and decay rate γ_k, with a learned gating π_k that determines which modes participate at which spatial locations. This effectively decomposes the velocity field into a set of basis evolution patterns that are combined to describe the full trajectory. Theorem 1 formally guarantees that with K = N modes, this parameterization can exactly match the teacher's velocity at N distinct timesteps — a representational completeness result that undergirds the method's ability to achieve high-fidelity alignment at very low NFE counts.

3. Technical Approach

3.1 Reader orientation

ArcFlow is a training framework that converts a slow, multi-step text-to-image diffusion model (the teacher) into a fast, 2-step generator (the student) by teaching the student to follow curved trajectories rather than straight-line shortcuts. The core problem it solves is that existing distillation methods force the student to approximate the teacher's smoothly curving denoising path with piecewise-linear segments, creating a fundamental geometric mismatch that degrades image quality; ArcFlow solves this by giving the student a velocity parameterization that natively produces curves, then analytically integrating those curves to compute exact state transitions without numerical error.

3.2 Big-picture architecture

The ArcFlow system has four major components working together during training:

• Frozen Teacher Model (G_ψ): A pre-trained multi-step diffusion model (Qwen-Image-20B or FLUX.1-dev) that serves as the ground-truth reference. It is never updated; it only provides target velocity vectors at queried timesteps.

• Student Backbone with Adapters (G_ϕ): The same architecture as the teacher, but with most weights frozen. Only lightweight LoRA adapters (rank-256) injected into specific feed-forward and projection layers, plus three new output projection heads, are trainable. The backbone takes a noisy latent x_t and timestep t, and the new heads predict the parameters needed for the momentum mixture.

• Momentum Mixture Parameterization: The three output heads predict the mode-specific velocities v_k, momentum factors γ_k, and gating probabilities π_k for K distinct evolution modes. These parameters define a continuous velocity field v_θ(x_t, t) that can represent non-linear trajectories through exponential decay laws.

• Analytic ODE Solver: A closed-form integration operator Φ that takes the momentum parameters and computes the exact latent displacement over any time interval without discretizing into sub-steps. This solver enables the student to jump from t_s to t_e in one shot while respecting the curved trajectory implied by its parameterization.

During inference, only the student backbone with adapters is used. The teacher and the analytic solver are training-only components.

3.3 Roadmap for the deep dive

• First, the momentum parameterization of the probability flow (Section 3.1 in the paper), because it defines what the student predicts and why those predictions can represent curved trajectories. This is the core representational innovation.

• Second, the analytic ODE solver (Section 3.2), because it shows how the momentum parameters are converted into actual latent state transitions without numerical error. This is the integration mechanism that makes the parameterization practically useful.

• Third, the flow distillation training procedure (Section 3.3), because it explains how the student is trained — the mixed integration curriculum, the velocity-matching loss, and the parameter-efficient adaptation strategy. This ties the theoretical framework to the practical training loop.

• Fourth, the training configurations and hyperparameters (distributed across Sections 4.1, Appendix C, and Appendix D), because they specify the exact engineering choices that make the method work on large-scale models.

3.4 Detailed, sentence-based technical breakdown

This is primarily a method paper whose core idea is that few-step distillation fails because linear shortcuts cannot represent the curvature of the teacher's denoising trajectory, and that this failure can be addressed by parameterizing the student's velocity field as a mixture of exponential momentum processes that admit exact analytic integration.

Momentum Parameterization of the Velocity Field

The starting point for ArcFlow is the observation that the teacher's denoising process follows a probability flow ODE (Appendix A, Eq. 8): dx_t/dt = u*(x_t, t), where u* is the ground-truth velocity field learned during pre-training. This ODE defines a continuous trajectory from noise (t=1) to data (t=0). The challenge is that u* varies with t — the direction and magnitude of the velocity change at every point along the path. A multi-step solver (Euler, Heun) samples this velocity at many timesteps and accumulates small linear steps, approximating the curve. A few-step student that uses linear steps implicitly assumes the velocity is constant within each large interval, which is equivalent to approximating a curve with a chord — the chord misses all the curvature between its endpoints.

ArcFlow's key insight is that the velocity evolution across timesteps has temporal structure that can be explicitly modeled. Specifically, velocities at adjacent timesteps are not independent random vectors; they are correlated because the denoising process is smooth. The paper captures this correlation through an analogy to physical momentum:

"the relationship between velocities at adjacent timesteps should follow a momentum transmission law parameterized by a factor γ. It implies that the velocity transfer as v(x_t, t) = v(x_{t+Δt}, t + Δt) · γ^{Δt} from t + Δt to t."

In plain language: if you know the velocity at some reference time t_s, you can predict the velocity at any earlier time t < t_s by multiplying the reference velocity by a decay factor γ raised to the power of the time difference. When γ < 1, the velocity decays as you move backward in time (toward data) — the trajectory slows down. When γ > 1, the velocity grows — the trajectory accelerates. When γ = 1, the velocity is constant, recovering the linear special case.

Applying this recursion repeatedly from a starting timestep t_s to any t ∈ [0, t_s) yields the expected velocity:

$E[v(x_t, t) | v(x_{t_s}, t_s), γ] = v(x_{t_s}, t_s) · γ^{t_s - t}$

where v(x_t, t) is the velocity at the target timestep, v(x_{t_s}, t_s) is the known velocity at the reference timestep, and γ ∈ ℝ⁺ is the momentum factor that controls the decay rate.

What it computes: Given a single velocity evaluation at t_s, this equation predicts the velocity at any earlier timestep t by applying exponential decay (or growth) governed by γ. The operation is: take the reference velocity vector, scale it by γ raised to the time difference. The output is the predicted velocity vector at t.

Why this form: The exponential form γ^{t_s - t} is not arbitrary — it satisfies a crucial property: the ratio of velocities at any two timesteps depends only on the time difference between them, not on their absolute positions. This time-translation invariance means the parameterization can extrapolate consistently across intervals of any length. A linear decay v(t_s) · (1 - α(t_s - t)) would not have this property — the velocity could become negative for large intervals, which is physically meaningless. The exponential ensures positivity and smoothness.

However, a single momentum factor γ is insufficient. Empirical evidence from the diffusion literature [8] shows that different spatial frequency components of an image evolve at different rates during denoising: coarse structure (low frequencies) stabilizes early, while fine details (high frequencies) continue to evolve until late in the process. A single γ would force all components to evolve at the same rate, missing this heterogeneity.

To address this, ArcFlow decomposes the velocity field into K distinct momentum modes, each representing a different evolution pattern. The full velocity at any timestep is a weighted mixture:

$v_θ(x_t, t) = Σ_{k=1}^K π_k(x_t) · v_k(x_t) · γ_k(x_t)^{1-t}$

where k ∈ {1, ..., K} indexes the modes, π_k(x_t) ∈ [0, 1] is the gating probability for mode k (subject to Σ π_k = 1), v_k(x_t) ∈ ℝ^D is the base velocity vector for mode k, and γ_k(x_t) ∈ ℝ⁺ is the momentum factor for mode k. Note the exponent is 1-t rather than t_s - t because the reference timestep is implicitly t = 1 (noise), so the velocity at t is the base velocity v_k decayed by γ_k over the interval from t = 1 to the current time.

What this parameterization represents: Each mode k defines a distinct evolution pattern — a base direction v_k and a decay rate γ_k. The gating π_k determines which modes are active at which spatial locations (the gating is predicted per-token by the network, so different image regions can follow different evolution patterns). The final velocity at (x_t, t) is the expected velocity across modes under the gating distribution.

Why a mixture is necessary: A single exponential mode K = 1 can only represent one evolution pattern. If the true velocity field requires the coarse structure to decay slowly (γ ≈ 0.9) while fine details decay quickly (γ ≈ 0.3), a single mode must compromise, degrading both. The mixture allows the model to simultaneously represent multiple evolution rates and interpolate between them through the learned gating. Theorem 1 proves that with K = N modes, the parameterization can exactly match the ground-truth velocity at N distinct timesteps — a completeness guarantee that a single mode cannot provide.

The parameters v_k, γ_k, and π_k are all predicted by the network from the input latent x_t and timestep t. Specifically, the student backbone G_ϕ processes (x_t, t) and produces three sets of outputs through dedicated projection heads:

• Velocity head: predicts the K base velocity vectors v_k(x_t). Each v_k is a D-dimensional vector where D is the latent dimension of the diffusion model (e.g., the flattened spatial latent for a DiT architecture). This head outputs K × D values.

• Momentum factor head: predicts log γ_k(x_t) for each mode. The log-parameterization (Appendix C.2) ensures γ_k = exp(log γ_k) is always positive without requiring explicit constraints. This head outputs K scalars.

• Gating head: predicts logits that are passed through a softmax to produce π_k(x_t). This head outputs K scalars.

All three heads operate on the same backbone features but produce independent outputs. The network is evaluated only once at the starting timestep of each step (e.g., at t_s = 1 for the first NFE, then at t_s = 0.5 for the second NFE). The momentum parameterization then extrapolates the velocity to any intermediate t using the exponential law, without additional network evaluations. This is what enables a 2-NFE model to capture velocity variation across a 50-step-equivalent trajectory: each NFE produces the parameters for a continuous curve, and the curve covers the velocity evolution within that half-interval.

A subtlety about the reference timestep: The parameterization in Eq. (2) uses exponent 1-t, which assumes the base velocity v_k is defined at t = 1 (pure noise). In practice, during multi-step inference, each step predicts parameters at its starting timestep t_s, and the effective exponent becomes t_s - t for that step's interval. The formulation is equivalent — the base velocity is always defined relative to the current evaluation point, and decay is computed from that point backward in time.

Theorem 1: Representational Completeness

The paper provides a formal guarantee that the momentum mixture parameterization is expressively sufficient to match the teacher's velocity field at a finite set of timesteps. This is a theoretical sanity check: it confirms that the parameterization is not structurally incapable of representing the target, regardless of how well optimization works.

Theorem statement (paraphrased): Consider the velocity field predicted by ArcFlow at any sampled latent y and timestep t, parameterized as v_θ(y, t) = Σ_{k=1}^K π_k(y) v_k(y) γ_k(y)^{1-t}. Let u*(y, t) denote the ground-truth velocity field, observed at N distinct timesteps T = {t_1, ..., t_N} ⊂ (0, 1]. If the number of modes satisfies K ≥ N, then there exists a parameter configuration θ = {π_k, v_k, γ_k}_{k=1}^K such that v_θ(y, t_n) = u*(y, t_n) for all t_n ∈ T.

What this means operationally: If you sample the teacher's velocity at N distinct timesteps along a trajectory, you can find settings of the momentum mixture parameters that reproduce those velocities exactly. The condition K ≥ N says that the number of modes must be at least the number of timesteps you want to match. With K = 16 modes (the default), the parameterization can exactly match the teacher at up to 16 timesteps — far more than the 2 NFEs used during inference.

The proof strategy (Appendix E.2) works by reducing the problem to solving a linear system. The key steps:

1. Decouple dimensions: The velocity field has D dimensions, but each dimension is independent in the parameterization. The problem reduces to D identical 1-D problems, so it suffices to prove the scalar case.

2. Introduce composite parameters: Define w_k = π_k v_k, absorbing the gating into the velocity. The objective becomes: find w_k and γ_k such that Σ_k w_k γ_k^{1-t_n} = u_n* for all n.

3. Fix γ_k to arbitrary distinct values: For the existence proof, the γ_k can be fixed to any set of K distinct positive numbers. This turns the problem into a linear system in the unknowns w_k: M c = b, where M_{nk} = γ_k^{1-t_n}, c_k = w_k, and b_n = u_n*.

4. Prove M is invertible: The matrix M is a generalized Vandermonde matrix whose columns are exponential functions evaluated at distinct points. The proof uses Chebyshev system theory: the set of functions {f_k(t) = γ_k^{1-t}} with distinct γ_k forms a Chebyshev system, meaning any non-trivial linear combination has at most K - 1 zeros. By the Haar condition, this implies the matrix with rows corresponding to distinct t_n is non-singular.

5. Conclude existence: Since M is invertible, the linear system M c = b has a unique solution c for any target b. This solution directly yields w_k, from which valid π_k and v_k can be recovered (e.g., set π_k = 1/K and v_k = K w_k).

Why this theorem matters for practical performance: It guarantees that the parameterization does not impose a structural ceiling on approximation quality. Any failure to match the teacher is due to optimization or finite data, not representational capacity. This contrasts with linear-step methods, where even with infinite data and perfect optimization, a 2-step linear trajectory would have non-zero error because two line segments cannot trace a general 50-step curve. The theorem does not guarantee that optimization will find the exact parameters (it's an existence proof, not a convergence proof), but it establishes that the solution space contains the true teacher trajectory — the student is not searching for something that doesn't exist in its hypothesis class.

Analytic ODE Solver: Exact Integration Without Discretization

Given the momentum parameterization of the velocity field, the next challenge is integration: how do we compute the latent state x_{t_e} starting from x_{t_s} given that the velocity v_θ(x_t, t) varies continuously with t? A numerical solver would discretize the interval [t_s, t_e] into small sub-steps, evaluate the velocity at each, and accumulate linear updates — exactly the approach that few-step methods are trying to avoid.

ArcFlow's second innovation is recognizing that the exponential form of the momentum parameterization admits a closed-form integral. Because each mode's velocity is v_k · γ_k^{1-t} — a constant vector multiplied by an exponential function of t — the integral over any time interval has a known analytic solution.

The derivation (Appendix E.1) works as follows. Define the Analytic Transition Operator Φ as the displacement induced by the velocity field v_θ when integrating from t_s to t_e (where t_s > t_e, meaning we integrate backward in time from noise toward data):

$Φ(x_{t_s}, t_s, t_e; θ) ≜ Δx_{t_s → t_e} = ∫_{t_e}^{t_s} v_θ(x_{t_s}, t) dt$

Note that v_θ depends on x_{t_s} (the state at the starting timestep) rather than the continuously varying x_t. This is an approximation — the velocity parameters are predicted once at t_s and assumed constant with respect to the integration variable — but it is the same approximation used by all few-step methods (the network is evaluated only at step boundaries). The key difference is that ArcFlow still integrates the time-dependence of the velocity function exactly, rather than approximating it as constant.

Substituting the momentum mixture (Eq. 2):

$Φ(x_{t_s}, t_s, t_e; θ) = Σ_{k=1}^K π_k(x_{t_s}) v_k(x_{t_s}) ∫_{t_e}^{t_s} γ_k(x_{t_s})^{1-t} dt$

The integral of the exponential term has a closed form. Define the Momentum Integral Coefficient C(γ, t_s, t_e) as:

$C(γ, t_s, t_e) = \begin{cases} \frac{γ^{1-t_e} - γ^{1-t_s}}{\ln γ}, & γ \neq 1 \\ t_s - t_e, & γ = 1 \end{cases}$

For γ ≠ 1, this follows from the standard integral:

∫ γ^{1-t} dt = γ ∫ e^{-t ln γ} dt = -γ e^{-t ln γ} / ln γ = -γ^{1-t} / ln γ

Evaluating from t_e to t_s yields (γ^{1-t_e} - γ^{1-t_s}) / ln γ.

For γ = 1, the integral reduces to ∫_{t_e}^{t_s} 1 dt = t_s - t_e, which is the standard linear step. The paper proves that this is the continuous limit as γ → 1 via L'Hôpital's rule or Taylor expansion (Appendix E.1), showing that the piecewise definition is smooth at the transition point.

Putting this together:

$Φ(x_{t_s}, t_s, t_e; θ) = Σ_{k=1}^K π_k(x_{t_s}) v_k(x_{t_s}) C(γ_k(x_{t_s}), t_s, t_e)$

where all parameters are evaluated at x_{t_s}.

What this computes: Given the momentum parameters predicted at t_s, the analytic operator computes the exact displacement from t_s to t_e under the assumption that the velocity follows the exponential momentum law. The operation is: for each mode, multiply the base velocity v_k by the scalar coefficient C(γ_k, t_s, t_e) and the gating weight π_k; sum across modes. The result is a displacement vector Δx of the same dimension as the latent. The next state is x_{t_e} = x_{t_s} - Φ.

Why this form matters: Compare this to the Euler update used by standard methods: x_{t-Δt} = x_t - v(x_t, t) · Δt. The Euler update treats the velocity as constant over Δt and multiplies by the interval length. ArcFlow's analytic update replaces the simple product v · Δt with the coefficient C(γ, t_s, t_e):

• When γ = 1, C = t_s - t_e, which is exactly Δt. ArcFlow recovers the Euler step as a special case.
• When γ < 1, C is strictly less than t_s - t_e because the velocity decays over the interval — the effective displacement is less than what a constant-velocity assumption would predict. Numerically: if γ = 0.5, t_s = 1.0, t_e = 0.0, then C = (0.5^1 - 0.5^0) / ln(0.5) = (0.5 - 1) / (-0.693) ≈ 0.721, which is less than the linear Δt = 1.0. This makes physical sense: the velocity is slowing down, so the total distance traveled is less than if it stayed at its initial speed.
• When γ > 1, C exceeds t_s - t_e because the velocity accelerates — the displacement is larger than the constant-velocity case.

This is the mechanism by which ArcFlow produces curved trajectories. A linear step v · Δt is a straight line from x_{t_s} to x_{t_s} - v · Δt. The analytic step Σ π_k v_k C(γ_k, t_s, t_e) follows a curved path whose shape is determined by the distribution of γ values across modes. The curve's instantaneous direction continuously rotates from the initial velocity toward the decayed velocity at the endpoint, even though the network was only evaluated once at the start.

Numerical stability: The paper implements a guard for |ln γ| < ε (with ε = 10^{-6} in practice), switching to the linear branch C = t_s - t_e to avoid division by near-zero. This prevents floating-point instability when modes operate near the linear regime.

Computational cost: Computing C for each mode requires one logarithm (ln γ), one exponentiation (γ^{1-t_e} and γ^{1-t_s}), and a few arithmetic operations per mode. For K = 16, this is negligible compared to the cost of running the neural network. The analytic solver is effectively free.

Flow Distillation Training Procedure

With the parameterization and solver defined, the training procedure teaches the student backbone to produce momentum parameters that make its integrated trajectories match the teacher's reference path. The training loop (Algorithm 1 in the paper) operates on individual timestep intervals and alternates between two steps: constructing target latents through mixed integration, and matching velocities at those latents.

Training objective: The core loss is instantaneous velocity matching. At a sampled latent x_t and timestep t, the student predicts its velocity v_θ(x_t, t; Θ) using Eq. (2), where Θ represents the momentum parameters derived from the student's evaluation at the interval's starting timestep. The teacher provides the ground-truth velocity u(x_t, t) by running its own forward pass. The loss is the squared L2 distance:

$L_{\text{distill}} = E_{t_i, x_{t_i}} [ ||v(x_{t_i}, t_i; Θ) - u(x_{t_i}, t_i)||^2 ]$

What it computes: At each sampled (x_t, t), both student and teacher predict a velocity vector of dimension D. The loss is the sum of squared differences across all dimensions. Minimizing this loss forces the student's velocity field to match the teacher's velocity field pointwise.

Why this form: Velocity matching is the natural objective for flow-based distillation because both models define their trajectories through velocity fields. If the student's velocity equals the teacher's velocity everywhere, the integrated trajectories will be identical. This is simpler than distribution matching (which requires adversarial training) or consistency-based objectives (which require Jacobian computations). However, the key challenge is that the student's velocity at (x_t, t) depends on parameters predicted at a different timestep t_s (the start of the interval), so the training must ensure the momentum extrapolation remains accurate across the interval.

The mixed latent integration curriculum (Algorithm 1): The training procedure for one interval [t_dst, t_src] works as follows:

1. Sample interval and initial noise: Sample a starting timestep t_src ∈ {1/NFE, 2/NFE, ..., 1}. For a 2-NFE model, this is either t_src = 0.5 or t_src = 1.0. Initialize x_{t_src} by adding noise to a real image according to the teacher's forward diffusion schedule at t_src.

2. Predict momentum parameters: Run the student backbone on (x_{t_src}, t_src) to obtain the momentum parameters Θ = {π_k, v_k, γ_k}_{k=1}^K. These parameters are used for the entire interval.

3. Sample intermediate checkpoints: Within the interval [t_src - 1/NFE, t_src], sample n intermediate timesteps {t_1, ..., t_n} (the paper uses n = 4). These are the points where velocity matching will be enforced.

4. Construct latents via mixed integration: For each intermediate timestep t_i, construct the latent x_{t_i} by integrating from t_src to t_i. However, rather than using purely student integration from the start (which would be inaccurate early in training when the student is untrained), the paper uses a mixed integration curriculum.

   Concretely, for each sub-interval from a checkpoint t_i to the previous checkpoint t_prev (or t_src for the first), introduce a switching timestep t_mix = t_prev - (1 - λ)(t_prev - t_i), where λ ∈ [0, 1] is a mixing ratio that increases from 0 to 1 during training.

   • Teacher phase: From t_prev to t_mix, use the teacher's velocity to integrate. Since these sub-intervals are small, the teacher's velocity is approximated as constant at u(x_{t_prev}, t_prev) for efficiency. The update: x_{t_mix} = x_{t_prev} + u(x_{t_prev}, t_prev) · (t_prev - t_mix).

   • Student phase: From t_mix to t_i, use the student's analytic solver. The update: x_{t_i} = x_{t_mix} - Φ(x_{t_src}, t_src, t_i; Θ) + Φ(x_{t_src}, t_src, t_mix; Θ). This leverages the analytic solver's ability to integrate over arbitrary intervals by computing the difference of two incomplete integrals from the common reference point t_src (see Appendix C.1, Eq. 13).

   When λ = 0, t_mix = t_i, so the teacher handles the entire sub-interval and the student contributes nothing — the latents stay exactly on the teacher's manifold. When λ = 1, t_mix = t_prev, so the student handles the entire sub-interval — the latents follow the student's own trajectories. By gradually increasing λ from 0 to 1 over the course of training (over 1000 steps for Qwen, 2000 for FLUX), the student progressively takes over integration responsibility while always starting from teacher-consistent states early on.

5. Velocity matching: At each constructed latent x_{t_i} (detached from the computation graph via stopgrad), compute the student's velocity v(x_{t_i}, t_i; Θ) using the momentum parameters and the teacher's velocity u(x_{t_i}, t_i) by forward-passing the teacher. Accumulate the L2 loss.

6. Update: Backpropagate through the student parameters ϕ (meaning through the backbone, LoRA adapters, and output heads). The teacher is frozen and the constructed latents are detached, so gradients only flow through the student's velocity predictions.

Why mixed integration is necessary: If the student were trained purely on its own integrated latents from the start ( λ = 1 immediately), the latents would quickly drift off the teacher's manifold due to the student's initial random parameterization. The student would then be learning to match velocities at states that the teacher never visits, which is a distribution shift problem. The teacher's velocity predictions on out-of-distribution states are unreliable, leading to compounding errors and slow convergence. The mixed curriculum keeps the latents anchored to the teacher's manifold early in training, providing clean supervision, then gradually transfers control to the student so it learns to self-correct on its own states.

The paper reports that this curriculum improves FID from 14.04 to 13.52 for Qwen and from 19.17 to 18.21 for FLUX (Table 7), confirming its practical importance for convergence quality.

Training interval coverage: The paper trains for NFE distinct intervals corresponding to the steps used during inference. For a 2-NFE model, the intervals are approximately [0.0, 0.5] and [0.5, 1.0], each spanning half the timestep range. During training, t_src is sampled uniformly from the set {1/NFE, ..., 1}, so each interval receives equal training attention. The intermediate checkpoints t_i are sampled uniformly within each interval, ensuring the student learns the velocity field at all sub-timesteps.

Parameter-efficient adaptation: The paper freezes the vast majority of the teacher backbone and trains only:

• LoRA adapters (rank 256) injected into specific layers. For Qwen-Image-20B: the image MLP projection layers, the timestep embedding linear layers, and the text MLP blocks across all transformer blocks. For FLUX.1-dev: the MLP projection layers, output projection head, feed-forward networks in both main and context branches, and timestep embedding layers. All other backbone weights remain frozen.

• Three output projection heads that predict the momentum parameters: velocity head, momentum factor head (predicting log γ), and gating head. These are trained from scratch.

The total trainable parameter count is "less than 5% of original parameters" (Section 1). This is a dramatic reduction compared to methods like TwinFlow and pi-Flow, which require full-parameter fine-tuning. The paper attributes this efficiency to the geometric compatibility argument: because the momentum parameterization can natively represent curved trajectories, the student doesn't need to overwrite the teacher's learned features to compensate for structural mismatch. The teacher's internal representations (learned during pre-training on massive data) remain valid; only the output mapping needs to be adapted to produce momentum parameters rather than single-step velocities.

Momentum factor-specific training details (Appendix C.2):

• Log-parameterization: The momentum factor head predicts log γ_k rather than γ_k directly. This is exponentiated to obtain γ_k = exp(log γ_k), which naturally enforces γ_k > 0 without constraints.

• Initialization: The log γ_k values are initialized as a geometric progression spanning [0.5, 4.0] (the γ space range). This means at initialization, the K = 16 modes cover γ values from 0.5 to 4.0 in geometric steps, providing initial diversity in evolution rates. One mode is explicitly fixed at γ = 1 (linear mode) as a stable anchor. The momentum factor head's linear layer is initialized with zero weights and the geometric log γ_k values as the bias, so initial predictions exactly match this range.

• Reduced learning rate: The momentum factor head uses a learning rate of 1 × 10^{-5}, which is 0.1× the base learning rate of 1 × 10^{-4} used for all other trainable parameters. This is necessary because γ appears in the exponent of the velocity field — small changes in log γ cause exponential changes in the effective velocity — making the loss landscape steeper in γ-space than in v-space or π-space.

Training hyperparameters (Table 6):

Training data: The paper uses a dataset of 2.3 million prompt-samples introduced by pi-Flow [4], which is "a large-scale prompt dataset" (Section 4.1). No further details about the dataset composition are provided.

Inference procedure: At inference time with 2 NFEs, the process is:

1. Sample initial noise x_1 ~ N(0, I).
2. First NFE: Run the student on (x_1, t=1) to obtain momentum parameters Θ₁. Apply the analytic solver to integrate from t=1 to t=0.5: x_{0.5} = x_1 - Φ(x_1, 1, 0.5; Θ₁).
3. Second NFE: Run the student on (x_{0.5}, t=0.5) to obtain momentum parameters Θ₂. Apply the analytic solver to integrate from t=0.5 to t=0: x_0 = x_{0.5} - Φ(x_{0.5}, 0.5, 0; Θ₂).
4. x_0 is the final generated latent, which is decoded to pixel space by the standard VAE decoder.

Each NFE evaluates the neural network once, so the total is 2 forward passes, compared to 50 for the teacher — the claimed 40× speedup (accounting for CFG overhead in the teacher's case, as noted in Table 1: "The NFE of Qwen-Image-20B is recorded as 50 × 2 since it uses CFG").

Why this entire approach works — the unification of parameterization, solver, and training: ArcFlow's three components form a coherent system where each piece addresses a specific limitation of linear distillation:

1. The momentum parameterization provides the capacity to represent curved trajectories. Linear methods lack this capacity regardless of training quality.

2. The analytic solver enables exact integration of those curves, eliminating the discretization error that would arise from numerically integrating a non-linear velocity field with sparse steps.

3. The mixed integration curriculum ensures the training signal remains on-manifold while the student learns to use its new parameterization. Without this, the student would receive noisy velocity targets at off-distribution states.

The result is that the student can match the teacher's full 50-step trajectory using only 2 neural network evaluations, not by learning to "guess" the endpoint with a straight shot, but by learning to trace the same curve using a more efficient representation of that curve.

4. Key Insights and Innovations

Innovation 1: Reframing Few-Step Distillation as a Geometric Compatibility Problem

The paper's most fundamental conceptual move is redefining the few-step distillation challenge from an optimization problem to a representational geometry problem. Prior work implicitly treated distillation as a compression task: the student must learn to "summarize" many teacher steps into fewer student steps through aggressive training, adversarial objectives, or distribution matching losses. The dominant assumption—visible in progressive distillation [23, 25], consistency models [22, 28], and distribution matching approaches [7, 39]—was that any performance gap could be closed by better optimization, more data, or more sophisticated loss functions.

ArcFlow argues this assumption is wrong. It diagnoses the primary bottleneck as a structural mismatch between the hypothesis space of the student's trajectory parameterization and the shape of the teacher's reference trajectory. Specifically: the teacher's 50-step denoising path is a smooth curve with continuously varying tangent directions. A student that models each step as a constant-velocity linear segment has a hypothesis space consisting exclusively of piecewise-linear paths. These two spaces are geometrically incompatible—no amount of training data or loss engineering can make a set of 2–4 straight line segments exactly trace a general 50-step curve. The residual error is not an optimization failure; it is a representational ceiling.

This reframing is significant beyond ArcFlow's specific solution because it provides a diagnostic lens for evaluating any distillation method. It explains why previous approaches exhibit systematic failure modes that are hard to fix with more training:

• Progressive distillation struggles in the few-step regime because repeated halving of NFEs cannot straighten trajectories sufficiently—the residual curvature at 2–4 steps exceeds what linear steps can absorb (Section 2).
• Adversarial methods like VSD [36] and TwinFlow [7] achieve sharp visuals but suffer mode collapse because the discriminator can penalize distribution mismatch but cannot correct the student's inability to reach certain regions of the teacher's distribution via non-linear paths. The student compensates by collapsing to modes it can reach with linear steps (Table 1: Qwen-Image-Lightning loses 85.7% in Diversity).
• Full-parameter fine-tuning is necessary for linear methods because the student must overwrite the teacher's pre-trained internal representations to absorb the curvature that its linear parameterization cannot explicitly model. The teacher's features are optimized for a 50-step regime where each step predicts a velocity at a single timestep; a 2-step linear student needs fundamentally different features to predict velocities that serve as multi-step chords (Section 3.3, Figure 2 convergence analysis).

Crucially, this framing is not just theoretical posturing—it has a testable empirical consequence. If geometric mismatch is the true bottleneck, then giving the student a parameterization that can natively represent curved trajectories should reduce the amount of training needed to reach high fidelity. This is exactly what ArcFlow demonstrates: it achieves state-of-the-art results with only LoRA adapters and output heads (less than 5% of parameters) and converges 4× faster than full-parameter linear baselines (Figure 2). The parameter efficiency and convergence speed are not independent achievements—they are joint consequences of geometric compatibility. The teacher's pre-trained backbone is already near a good local optimum for the student's parameterization because the momentum formulation respects the curvature the teacher's trajectory already has.

This contribution is foundational rather than incremental—it changes the question from "how can we train students better?" to "what can the student represent in the first place?" It establishes geometric mismatch as a first-class diagnostic concept in distillation research, analogous to how the bias-variance tradeoff or capacity-vs-expressivity framing shaped supervised learning.

Innovation 2: Velocity Field Parameterization with a Representational Completeness Guarantee

The second distinctive contribution is the momentum mixture parameterization—not merely as a practical technique, but as a representationally complete velocity model with a formal guarantee. While previous methods (pi-Flow [4], GM-FM [5]) also recognized that velocities evolve across timesteps and attempted to model this evolution through Gaussian mixtures, they did so through probabilistic approximations that lacked precision guarantees. ArcFlow's parameterization is qualitatively different in three ways.

First, it operates deterministically on the velocity field rather than probabilistically on the data distribution. The momentum mixture defines v(x_t, t) = Σ π_k v_k γ_k^{1-t} directly as a function of time. This is a velocity field model, not a distribution model—it specifies how the state changes at each instant, which integrates to a trajectory. Gaussian mixture methods, by contrast, model the probability path from noise to data and derive velocities implicitly. The deterministic velocity approach is simpler to train (L2 velocity matching vs. imitation learning) and admits exact integration.

Second, it provides a completeness theorem (Theorem 1) that no prior few-step method possesses. Theorem 1 proves that with K = N momentum modes, ArcFlow can exactly match the teacher's velocity at N distinct timesteps for any state on the data manifold. This is a representational completeness guarantee: the parameterization's hypothesis space contains the teacher's velocity field at any finite set of observation points. No linear-step method can make such a claim—two linear segments cannot match velocities at 50 distinct timesteps for an arbitrary curve, regardless of parameter settings.

The significance of Theorem 1 is not that ArcFlow will actually achieve exact matching in practice (optimization may not find the exact parameters, and there are only K = 16 modes, not K = 50). Rather, it guarantees that any residual error is an optimization or finite-data issue, not a structural representational one. This converts a previously unknown ceiling into a known, improvable bound: improving the optimizer, training data, or modal count should monotonically improve fidelity. For linear-step methods, the situation is fundamentally different—there exists a non-zero minimum error that no amount of optimization can eliminate because the target trajectory lies outside the student's hypothesis space. This is the distinction between an approximator (which can get arbitrarily close with sufficient capacity) and an incomplete model class (which cannot represent the target at all).

Third, the proof technique itself is notable: it reduces the problem to a Chebyshev system analysis via generalized Vandermonde matrices. By showing that the exponential functions γ_k^{1-t} with distinct γ_k form a Chebyshev system (any non-trivial linear combination has at most K-1 zeros), the proof leverages classical approximation theory to establish invertibility of the basis matrix at any set of distinct timesteps. This is a clean theoretical bridge between the physics-inspired momentum concept and the mathematical foundations of function approximation. It also explains why the exponential form is necessary: other decay laws (linear, polynomial) would not yield Chebyshev systems and therefore would not enjoy the same completeness property.

The practical manifestation of this completeness guarantee appears in the ablation on K (Table 5): increasing modes from 8 to 16 improves FID (12.54 → 12.40) and pFID (4.17 → 3.78) monotonically, with diminishing returns from 16 to 32 (FID 12.40 → 12.39, pFID 3.78 → 3.69). This is consistent with the theory—more modes increase representational capacity—but also shows that practical limits (training stability, overfitting) kick in before the theoretical ceiling.

This is an incremental but rigorous advance over prior mixture-based velocity models. It takes the intuition that "velocities evolve" and formalizes it into a parameterization with known approximation properties, converting a heuristic into a principled design choice.

Innovation 3: Exact Analytic Integration Enabling High-Precision Sparse-Step Transitions

ArcFlow's third distinctive contribution is the elimination of numerical integration error in sparse-step trajectories through closed-form analytic integration. This may seem like a "merely" computational improvement, but its conceptual implications run deeper.

The standard approach to ODE integration in both multi-step teachers and few-step students is numerical discretization: approximate the integral of the velocity field over a timestep interval by evaluating the velocity at a few points and applying a quadrature rule (Euler, Heun, RK4). For multi-step teachers with 50 NFEs, the discretization error per step is small because each step spans only ~0.02 in normalized time. But for a few-step student with 2 NFEs, each step spans 0.5 in time—25× larger. If the student still uses numerical integration within each step (e.g., evaluating the velocity at multiple sub-timesteps), it incurs either discretization error (if using coarse sub-steps) or defeats the purpose of few-step distillation (if using many sub-steps).

ArcFlow's momentum parameterization circumvents this dilemma entirely because the exponential form v_k · γ_k^{1-t} has a known antiderivative. The integral over any interval [t_e, t_s] is computable in O(K) time via the analytic coefficient C(γ, t_s, t_e) without any sub-sampling. This means the student can take arbitrarily large steps—from t=1 to t=0.5, from t=0.5 to t=0—and the latent transition is exact under the assumed velocity model. There is no trade-off between step size and integration accuracy.

This is not merely an engineering convenience. It fundamentally changes the nature of the approximation:

• Linear-step methods with numerical integration approximate the teacher's continuous curve with a chord (the straight line between endpoints). The chord misses all curvature between the endpoints. This error is geometric—it comes from the shape mismatch—and cannot be reduced by more accurate integration because the model already assumes the velocity is constant.

• ArcFlow with analytic integration approximates the teacher's curve with a curve that has the same functional form (exponential) as the assumed velocity model. This curve can bend to follow the teacher's curvature. The only approximation is that the curve's parameters (predicted at the start of the step) are assumed constant for the step duration, rather than updated continuously as the state evolves. This is analogous to the semi-implicit assumption in numerical ODE solvers—and it is the same order of approximation that multi-step teachers use when they evaluate the network at discrete timesteps.

The practical consequence is validated in the quantitative results. ArcFlow achieves pFID scores (Table 2: 3.78 for Qwen, 11.20 for FLUX) that dramatically outperform linear-step methods (TwinFlow: 4.34, pi-Flow: 12.42 for Qwen; pi-Flow: 37.84 for FLUX) when measured against the 50-step teacher's distribution. pFID is particularly sensitive to local texture and fine-detail alignment—exactly the aspects where integration error would manifest as blur or noise. The large gap (3.78 vs. 37.84 for FLUX-based methods) suggests that integration error, not just global structure, is a dominant source of quality degradation in linear methods.

This contribution is incremental in mechanism but fundamental in effect. Closed-form integration of exponential mixtures is a standard calculus exercise; the innovation lies in recognizing that this mathematical property enables a qualitative leap in few-step trajectory fidelity, and then designing the entire distillation framework around it.

Innovation 4: Geometric Compatibility as a Unifying Explanation for Training Efficiency

While Innovations 1–3 describe the what and how of ArcFlow, the fourth innovation is a meta-insight that emerges from the empirical evidence: the difficulty of distillation training—measured by convergence speed, parameter update magnitude, stability, and data requirements—is primarily determined by the geometric compatibility between the student's trajectory parameterization and the teacher's reference trajectory.

This insight is supported by a constellation of empirical findings that individually could be dismissed as implementation details, but collectively form a coherent pattern:

• Convergence speed (Figure 2): ArcFlow reaches competitive FID scores in ~1,000 training steps, compared to ~4,000 for pi-Flow and significantly more for TwinFlow. The paper attributes this to ArcFlow's ability to start from the teacher's pre-trained weights and only require minor adaptation, whereas linear methods must undergo large parameter changes to override the teacher's features.

• Parameter efficiency (Section 4.1, Table 6): ArcFlow achieves state-of-the-art results with less than 5% of parameters trainable. Full-parameter methods like TwinFlow and pi-Flow must update the entire backbone. The geometric explanation: if the student's output space (curves) is compatible with the teacher's features (trained for a 50-step curve), then the teacher's internal representations already encode useful information for the student's task. Only the output mapping needs adjustment. If the student's output space (straight lines) is incompatible, the teacher's features are optimized for the wrong output geometry and must be substantially overwritten.

• Training stability (Section 4.2, Figure 2): ArcFlow's FID curve shows monotonic improvement with low variance. TwinFlow, in contrast, exhibits oscillations characteristic of large-parameter optimization from a poor initialization. The geometric interpretation: when the target trajectory is near the student's hypothesis space, the loss landscape is locally convex and well-conditioned; when it's far away, the landscape has deep valleys and sharp ridges corresponding to different ways of "forcing" a straight line to approximate a curve.

• The mixed integration curriculum's effectiveness (Table 7): The fact that gradually transferring integration responsibility from teacher to student improves FID (14.04 → 13.52 for Qwen, 19.17 → 18.21 for FLUX) is expected if early student trajectories are geometrically inaccurate. But the degree of improvement is notable—it suggests that without the curriculum, the student receives velocity matching targets at states that are off the teacher's manifold, and these targets are themselves unreliable because the teacher's velocity predictions on out-of-distribution latents are noisy. This is a compounding error problem that geometric incompatibility exacerbates.

This insight is fundamentally a reframing, not a new technique. It says that if you want efficient distillation, you should first ask "can my student's parameterization represent the teacher's trajectory shape?" rather than "how should I tune my loss function or optimizer?" It explains why some distillation methods require adversarial objectives (to compensate for distribution shift caused by geometric mismatch), others require progressive halving (to slowly straighten trajectories until they're approximately linear), and still others require full-model fine-tuning (to repurpose features for a geometrically different task).

The practical implication is that future distillation research should evaluate candidate student parameterizations on their representational compatibility with the teacher before optimizing training. A student that can natively produce curves should be preferred over one that can't, even at equal parameter count, because the training process will be fundamentally easier. This is an instance of the broader principle that aligning inductive biases with the structure of the target function reduces sample complexity and optimization difficulty—a principle well-established in supervised learning but only implicitly recognized in the distillation literature before ArcFlow.

5. Experimental Analysis

Evaluation Methodology

• Dataset. The paper evaluates on three standard benchmarks: (1) Geneval [12], which focuses on complex object combination and attribute binding; (2) DPG-Bench [16], which tests dense and long prompt understanding; and (3) OneIG-Bench [3], which evaluates image generation from complex prompts across five distinct dimensions (Alignment, Text, Diversity, Style, Reasoning). Additionally, the authors construct Align5000, a custom dataset of 5,000 prompts comprising 3,200 prompts from the HPSv2 prompt set [38] and 1,800 prompts randomly sampled from the COCO 2014 validation set [19], designed to span both artistic styles and natural image distributions for comprehensive teacher-alignment evaluation.

• Base model(s). All experiments use two large-scale text-to-image models as teachers: Qwen-Image-20B [37] (a 20-billion-parameter flow matching model with Transformer backbone) and FLUX.1-dev [17] (Black Forest Labs' flow-based model). These were chosen to demonstrate ArcFlow's applicability across different model families and scales, and because they represent state-of-the-art multi-step text-to-image generation quality, making them challenging distillation targets.

• Metrics. Four metrics are used to evaluate generation quality and teacher alignment:

  • FID (Fréchet Inception Distance) and pFID (patch FID, patch size 64, stride 128): Both computed against 50-step teacher generations on Align5000. These measure how closely the student's output distribution matches the teacher's reference distribution, with pFID being more sensitive to local texture and fine-detail alignment.
  • CLIP similarity score: Measures prompt-image alignment by computing cosine similarity between CLIP embeddings of the prompt and the generated image, evaluated on Align5000.
  • Benchmark-specific metrics: Geneval, DPG-Bench, and OneIG-Bench each produce aggregate scores capturing different aspects of image quality and text alignment (higher is better for all).

• Baselines. The paper compares against multiple state-of-the-art few-step distillation methods at 2 NFEs:

  • For FLUX.1-dev: SenseFlow [10] (uses Distribution Matching Distillation), pi-Flow (GM-FLUX) [4] (uses policy-based imitation distillation with Gaussian mixture approximation).
  • For Qwen-Image-20B: Qwen-Image-Lightning [24] (uses Variational Score Distillation with adversarial objectives), TwinFlow [7] (uses self-adversarial flow distillation with full-parameter training), pi-Flow (GM-Qwen) [4].
  • The 50-step teacher (Qwen-Image-20B at 50×2 NFEs due to classifier-free guidance, FLUX.1-dev at 50 NFEs) serves as the upper-bound reference.

• Generation budget / compute accounting. The generation budget is measured in NFEs (Neural Function Evaluations) — the number of forward passes through the student network. All student methods are set to NFE = 2, achieving approximately a 40× speedup over the teacher. The teacher Qwen-Image-20B uses 50 steps with classifier-free guidance (CFG), requiring two forward passes per step, hence recorded as 50 × 2 NFEs. The paper notes that the 40× figure accounts for this CFG overhead. Inference time measurements (Appendix F.3, Table 8) confirm that ArcFlow's 2-NFE latency (1.411s for Qwen, 1.466s for FLUX at 1024×1024) is comparable to fully fine-tuned baselines despite using LoRA adapters, with only a negligible overhead from the additional projection heads.

• Cross-validation / statistical protocol. The paper does not describe explicit cross-validation or statistical significance testing. Results are reported as single-point evaluations on the standard test sets. The convergence analysis (Figure 2) evaluates models at 500-step intervals during training, but no confidence intervals or error bars are reported for the final benchmark scores. For the Align5000 FID and pFID metrics, the paper computes these against a fixed set of 50-step teacher generations, making the comparison deterministic given the student checkpoint.

Main Quantitative Results

Benchmark Performance (Geneval, DPG-Bench, OneIG-Bench)

Table 1 presents the comprehensive comparison across all three benchmarks. For Qwen-Image-20B-based students at 2 NFEs:

• ArcFlow-Qwen achieves Geneval 0.85, matching Qwen-Image-Lightning (0.85) and surpassing pi-Flow (0.83) and TwinFlow (0.82). The 50-step teacher achieves 0.87, meaning ArcFlow retains 97.7% of the teacher's Geneval performance with only 2 NFEs.

• On DPG-Bench, ArcFlow-Qwen achieves 88.46, the highest among all 2-step students, slightly exceeding Qwen-Image-Lightning (88.42) and substantially outperforming TwinFlow (87.01) and pi-Flow (86.45). This surpasses even the teacher's reported score of 88.32 — a result that may reflect evaluation variance or the fact that teacher scores are "cited from pi-Flow and TwinFlow" (noted with † in the table).

• On OneIG-Bench, the pattern reveals ArcFlow's distinctive strength in diversity preservation. ArcFlow-Qwen achieves Diversity of 0.182, compared to Qwen-Image-Lightning's 0.098 — an +85.7% relative improvement. This is the key differentiator from adversarial methods. Qwen-Image-Lightning sacrifices diversity for prompt alignment (scoring higher on Text: 0.879 vs. ArcFlow's 0.853), but ArcFlow maintains both strong alignment (Alignment: 0.877 vs. Lightning's 0.875) and substantially higher diversity. The teacher achieves Diversity 0.194, so ArcFlow preserves 93.8% of the teacher's diversity, while Lightning preserves only 50.5%.

For FLUX.1-dev-based students at 2 NFEs:

• ArcFlow-FLUX achieves Geneval 0.65, significantly outperforming SenseFlow (0.60), pi-Flow (GM-FLUX, 0.58), and approaching the teacher's 0.66. The gap from teacher is only 0.01, compared to 0.06 for the next-best competitor.

• On DPG-Bench, ArcFlow-FLUX achieves 84.29, surpassing the teacher's 84.16 and substantially exceeding pi-Flow (82.36) and SenseFlow (79.86). The fact that ArcFlow exceeds the teacher's DPG-Bench score is notable — the paper does not discuss this phenomenon explicitly, but it may reflect the distillation process acting as a form of regularization that improves prompt alignment on certain benchmarks, or evaluation variance on the DPG-Bench.

• On OneIG-Bench, ArcFlow-FLUX dominates across all sub-dimensions: Alignment (0.798 vs. pi-Flow's 0.764 and teacher's 0.790), Text (0.368 vs. pi-Flow's 0.141 — a 2.6× improvement), Diversity (0.210 vs. pi-Flow's 0.216, statistically indistinguishable), Style (0.350 vs. pi-Flow's 0.332), and Reasoning (0.224 vs. pi-Flow's 0.212). The exceptionally poor Text score of pi-Flow (0.141) on FLUX indicates fundamental difficulties with text rendering — a well-known challenge for few-step distillation that ArcFlow substantially mitigates.

Teacher Alignment Results (Align5000)

Table 2 presents FID, pFID, and CLIP scores computed on Align5000, measuring distribution-level alignment with the 50-step teacher.

• ArcFlow-Qwen achieves FID 12.40 and pFID 3.78, the best among all methods. For comparison: Qwen-Image-Lightning achieves FID 16.86 and pFID 11.32, TwinFlow achieves FID 16.77 and pFID 4.34, and pi-Flow achieves FID 20.07 and pFID 12.42. ArcFlow's pFID of 3.78 is 2.94× better than Lightning's 11.32 and 3.28× better than pi-Flow's 12.42, indicating dramatically superior local detail preservation. TwinFlow's pFID of 4.34 is competitive but still 14.8% worse than ArcFlow's.

• ArcFlow-FLUX achieves FID 16.83 and pFID 11.20. SenseFlow achieves pFID 9.25 (lower/better than ArcFlow's 11.20), but its FID of 27.55 is substantially worse than ArcFlow's 16.83 — a 38.9% improvement. pi-Flow (GM-FLUX) achieves the worst results: FID 32.62 and pFID 37.84. The pFID gap between ArcFlow (11.20) and pi-Flow (37.84) is 3.38×, confirming that the non-linear trajectory parameterization makes an enormous difference for FLUX-based distillation, where linear methods struggle severely.

• CLIP scores are consistently high across methods: ArcFlow-Qwen achieves 0.325 (matching the teacher), TwinFlow and Lightning achieve 0.320, pi-Flow achieves 0.323. All methods are within 0.005 of the teacher. This indicates that prompt-alignment is relatively easy to preserve during distillation — it's the distributional fidelity (FID/pFID) where methods diverge substantially.

Why FID and pFID diverge from Geneval/DPG-Bench: The paper includes a discussion of Qwen-Image-Lightning in Appendix B that explains this phenomenon. Lightning achieves strong prompt-alignment scores (Geneval 0.85, DPG-Bench 88.42) but inferior FID/pFID (16.86/11.32), which the paper attributes to a trade-off where "perceptual optimization compromises trajectory fidelity." In essence, adversarial objectives can push the student to produce images that satisfy the prompt and look sharp to discriminators, but that deviate from the teacher's precise output distribution — they "sacrifice fine-grained visual fidelity for better semantic alignment." ArcFlow avoids this because its velocity-matching objective directly enforces trajectory-level alignment with the teacher, preserving both prompt-following ability and distributional fidelity.

Convergence Speed and Training Stability

Figure 2 compares FID trajectories across training iterations for ArcFlow, pi-Flow, and TwinFlow, all distilled on Qwen-Image-20B with a batch size of 16. The headline result:

• ArcFlow reaches competitive FID after ~1,000 training steps, while pi-Flow requires approximately 4,000 steps and TwinFlow requires substantially more. The paper explicitly states: "ArcFlow surpasses the FID of Qwen-Image-Lightning after only 1,000 training steps." Given that Lightning was trained with a full adversarial pipeline on much larger compute, this is a striking efficiency claim — ArcFlow matches a production-quality 2-step model in ~13% of its own total training duration (1,000 / 7,500 steps).

• ArcFlow's FID curve is monotonic and stable, with low variance across iterations. TwinFlow's curve shows oscillations characteristic of large-parameter optimization from a poor initialization. The paper attributes this to the geometric mismatch forcing TwinFlow to "override the teacher's pre-trained weights" and "re-learn a viable representation from a high-error state" (Appendix F.2).

• Appendix F.2 provides qualitative visualization of this convergence (Figure 8). At 0.5K training steps, ArcFlow already produces images with "coherent global structure" and "most stochastic artifacts and irregular noise largely suppressed." The main deficiency is "mild over-smoothing, rather than structural corruption." pi-Flow preserves global structure but "consistently struggles with residual noise artifacts" that persist throughout training. TwinFlow shows "the weakest convergence behavior," with significantly slower visual quality improvement at early stages.

Interpretation: The convergence speed advantage is not incidental — it is a direct consequence of ArcFlow's parameter-efficient adaptation strategy. Because the momentum parameterization is geometrically compatible with the teacher's trajectory, the student can start from the teacher's pre-trained weights and only require minor adaptation through LoRA. The teacher's internal features — learned during massive pre-training — remain valid for the curved trajectories that ArcFlow produces. Linear methods like TwinFlow cannot reuse these features as effectively because the teacher's features are optimized for a 50-step regime where each evaluation predicts a single-timestep velocity, not a multi-step chord. The convergence speed gap quantifies how much "re-learning" is needed to compensate for geometric mismatch.

Parameter Efficiency

The paper claims ArcFlow fine-tunes "less than 5% of original parameters" (Section 1). Concretely (Table 6, Section 4.1): only rank-256 LoRA adapters injected into specific feed-forward and projection layers, plus the three new output projection heads (velocity, momentum factor, gating), are trainable. All other backbone weights are frozen.

By contrast, TwinFlow [7] and pi-Flow [4] require full-parameter fine-tuning of the entire 20B-parameter backbone. SenseFlow [10] uses DMD, which also typically involves full model training. The practical implications: ArcFlow's training requires proportionally less GPU memory (since optimizer states are only maintained for LoRA parameters), and the resulting checkpoint is smaller (LoRA weights can be stored separately from the frozen base model). The paper does not report exact parameter counts or memory usage comparisons, but the "less than 5%" figure serves as the quantitative anchor.

Ablation Studies and Robustness Checks

All ablations in Tables 3–5 and Table 7 are conducted on Align5000 with reduced training budgets (1,500–3,000 training steps) to isolate the effect of individual design choices.

Impact of momentum dynamics (γ): Removing the momentum factor by setting γ ≡ 1 (Table 3) degrades FID from 14.56 (learnable γ) to 17.06 — a 17.2% relative increase in distributional distance. This setting reduces ArcFlow to a pure velocity mixture without temporal structure, forcing the model to "implicitly compensate for the overall dynamics information" through the velocity vectors alone. Introducing fixed momentum factors (geometric initialization spanning [0.5, 4.0] but kept frozen during training) partially recovers performance (FID 14.77), and making γ learnable further improves to FID 14.56. The paper interprets this as evidence that "adaptive momentum factors better capture the varying trajectory behaviors across different samples and timesteps." Figure 6(a) qualitatively shows that the γ ≡ 1 setting produces less detailed images with weaker structural coherence. This ablation confirms that the momentum factor is not merely an architectural frill — it provides representational capacity that cannot be recovered by increasing the number of velocity modes alone (since γ ≡ 1 with K = 16 still has 16 velocity modes but lacks temporal evolution structure).

Decoupling velocity and momentum mixtures: The paper explores whether velocity diversity and momentum diversity can be decoupled (Table 4). The configuration (N_v, N_γ) specifies how many independent base velocities and momentum factors are used across the K = 16 mixture modes. (K, K) (the default) uses 16 distinct velocities and 16 distinct momentum factors. (K, 1) forces all 16 modes to share a single γ — diverse velocity directions but uniform evolution rate across modes. (1, K) forces all 16 modes to share a single base velocity v — diverse evolution rates but all pointing in the same direction.

• (K, 1) achieves FID 15.08, worse than the default's 14.56. This shows that having diverse velocities without diverse evolution rates is insufficient — different velocity components benefit from evolving at different rates, and forcing them to share one γ creates a bottleneck.

• (1, K) achieves FID 14.97, intermediate between (K, 1) and (K, K). This shows that momentum diversity helps even when velocity directions are shared, but combining both types of diversity provides the best result.

Figure 6(b) qualitatively confirms these patterns. The key insight: "decoupling velocity and momentum clarifies the optimization task, while constraining either factor forces the remaining parameters to implicitly compensate for the missing dynamics, creating an overloaded and ambiguous learning target." In other words, when the model has fewer explicit degrees of freedom, the optimization must find more circuitous solutions in the remaining parameter space, which slows convergence and increases final error.

Scalability of mixture components K: Increasing the number of momentum modes from 8 to 32 (Table 5) shows monotonically improving but diminishing returns:

The improvement from 8 to 16 modes is meaningful (FID drops 0.14, pFID drops 0.39), but from 16 to 32 the gain is marginal (FID drops 0.01, pFID drops 0.09). The paper selects K = 16 as the default, citing "diminishing returns, the increased parameter, and computational cost." This is consistent with Theorem 1's theoretical picture: with K = 16 modes, the parameterization can exactly match the teacher at up to 16 timesteps, which is already far more than the 2 NFEs used during inference. Increasing K to 32 allows exact matching at up to 32 timesteps, but since the training only uses n = 4 intermediate timesteps per interval (Table 6), the additional representational capacity goes largely unused. The residual error at K = 16 is likely dominated by optimization and finite data, not by representational insufficiency.

Mixed trajectory integration curriculum: Table 7 reports that removing the mixed integration strategy (setting λ = 1 from the start, meaning student-only integration throughout training) degrades FID for both backbones:

The improvement is consistent but modest — a 3.7% relative FID improvement for Qwen and 5.0% for FLUX. Figure 7 shows qualitative differences: without mixed integration, images are "smoother and less detailed," with the paper noting that "the student is more prone to learning inaccurate velocity estimates at early stages, which leads to slower and less stable convergence." This confirms that the curriculum serves primarily as a convergence aid — it keeps early training latents on the teacher's manifold so the student receives clean supervision — rather than changing the asymptotic performance ceiling. The mechanism aligns with standard curriculum learning intuitions: start with an easier task (velocity matching on teacher-consistent states) and gradually increase difficulty (velocity matching on student-generated states).

Inference time measurements (Appendix F.3, Table 8): An efficiency-focused ablation comparing wall-clock inference time across methods at 1024×1024 resolution with 2 NFEs:

ArcFlow-Qwen's 1.411s is only 2.8% slower than TwinFlow (1.372s), despite TwinFlow using full-parameter fine-tuning with no additional computational overhead at inference. Qwen-Image-Lightning is slowest (1.718s) due to its use of multiple LoRA adapters. The paper correctly notes that ArcFlow's additional parameters (momentum and gating heads) "incur only a negligible increase in floating-point operations." The analytic solver itself is computationally trivial — O(K) scalar operations per mode — relative to the neural network forward pass.

Critical Assessment

Does geometric compatibility actually explain the performance gains, or is it multi-modal capacity?

The paper's central claim is that non-linear trajectory parameterization resolves a geometric mismatch, and that this geometric compatibility is what enables parameter efficiency, fast convergence, and high fidelity. The experimental evidence is consistent with this narrative but does not fully distinguish it from a simpler alternative hypothesis: ArcFlow benefits primarily from having more parameters dedicated to modeling the velocity evolution (via the momentum mixture) rather than from the specific geometric form of that parameterization.

Consider: ArcFlow adds K velocity vectors, K momentum factors, and K gating probabilities per NFE — this is 16× more velocity-related parameters than a standard linear-step student, which outputs only a single velocity vector per NFE. It's possible that any method that increases the representational budget for velocity modeling (e.g., predicting a higher-order Taylor expansion, or a learned polynomial velocity profile) would achieve similar gains, without the specific exponential momentum formulation. The ablation on γ (Table 3) partly addresses this: setting γ ≡ 1 removes the temporal structure but retains the K velocity modes, and FID degrades from 14.56 to 17.06. This shows that the exponential form specifically matters. But it doesn't test whether other forms (e.g., predicted polynomial coefficients with analytic polynomial integration) would work equally well. The Chebyshev system proof (Theorem 1) provides theoretical justification for the exponential choice, but the experiments don't benchmark against alternative non-linear parameterizations.

The single-task evaluation limits generality claims.

All results are on text-to-image generation with two specific model families (Qwen-Image-20B and FLUX.1-dev). The paper does not evaluate on other modalities (e.g., text-to-video, audio generation, molecular conformer generation) where flow matching is also used. The claim that ArcFlow "respects the underlying flow dynamics" (Conclusion) is a general statement about flow matching distillation, but the experiments only verify it for image generation with large Transformer backbones. The momentum parameterization's effectiveness may depend on the smoothness properties of the velocity field, which could differ across modalities.

The 2-step focus leaves the 1-step regime unexplored as a limitation, not a solved problem.

The paper explicitly acknowledges in Appendix G that ArcFlow "exhibits severe degradation in generation quality and fails to produce meaningful results" at 1 NFE. This is attributed to the "difficulty of accurately modeling the momentum factor γ under a 1 NFE regime, where γ becomes highly sensitive and challenging to predict without sufficient modeling capacity." In other words, when the entire denoising trajectory must be captured in a single exponential curve, the momentum parameterization becomes unstable — the model must predict γ values that extrapolate accurately over the full [0, 1] interval, which amplifies prediction errors exponentially.

This is a genuine limitation that the paper is transparent about. However, it also somewhat undermines the "geometric compatibility" narrative: if the momentum parameterization were truly geometrically compatible with the teacher's trajectory, one might expect it to work in the 1-step limit as well (perhaps with more modes or better γ initialization). The fact that it fails suggests that K = 16 modes evaluated at a single timestep cannot represent the full 50-step trajectory's curvature — the representational completeness guarantee (Theorem 1) assumes the ability to match velocities at K timesteps, but in the 1-NFE case, all K modes are predicted from a single state x_1, and the exponential extrapolation must be accurate over the entire interval without any intermediate correction. This is a harder requirement than the theorem addresses.

Missing ablation: comparison against a linear-step baseline with equivalent parameter count.

A fair test of whether the non-linear parameterization itself, rather than increased parameter count, drives the gains would be: give a linear-step student an equivalent increase in parameters by expanding its output head (e.g., predict 16 velocity vectors instead of 1, and average them), then compare. This ablation is not present. The comparison methods (pi-Flow, TwinFlow) have different architectural choices and training procedures beyond just linear vs. non-linear trajectories, so performance gaps cannot be purely attributed to the trajectory parameterization. The paper argues that the parameter efficiency is a consequence of geometric compatibility, but without this controlled ablation, it's equally consistent with the explanation that ArcFlow simply adds useful capacity in a regularization-friendly way (LoRA) that happens to outperform full-parameter competitors.

The convergence speed comparison uses small batch sizes.

Figure 2 is generated with a batch size of 16, while the full training uses a batch size of 384 (Table 6). Convergence behavior can depend substantially on batch size, particularly for methods using adversarial objectives (which benefit from larger batches for discriminator training). Training pi-Flow and TwinFlow at batch size 16 may disadvantage them relative to their optimal settings, potentially exaggerating ArcFlow's convergence advantage. The paper does not report whether the competing methods were also tuned for the 16-batch regime.

The 40× speedup is measured against the teacher's full CFG pipeline, not a fair 2-NFE CFG baseline.

The teacher Qwen-Image-20B uses 50 × 2 = 100 forward passes due to CFG, so ArcFlow's 2 NFEs represent a 50× reduction in network evaluations (100 → 2). The 40× figure accounts for the fact that ArcFlow uses 2 NFEs, but the paper doesn't clarify whether this is wall-clock time or NFE count. Table 8 shows ArcFlow-Qwen at 1.411s inference time, but does not report the teacher's inference time for direct comparison. The speedup claim would be stronger with a wall-clock time measurement of both teacher and student on identical hardware.

Benchmark scores exceeding the teacher raise questions about evaluation validity.

ArcFlow-Qwen exceeds the teacher on DPG-Bench (88.46 vs. 88.32) and ArcFlow-FLUX exceeds its teacher on both Geneval (0.65 vs. should be near 0.66, but this is within margin) and DPG-Bench (84.29 vs. 84.16). These teacher scores are marked with † ("cited from pi-Flow and TwinFlow"), meaning they were not re-evaluated by the ArcFlow authors under identical conditions. Evaluation differences (random seed, prompt sampling, metric implementation details) could account for small discrepancies. This doesn't invalidate the comparisons among students (which are evaluated consistently), but it means the claim that ArcFlow "matches" the teacher should be interpreted as "achieves scores within evaluation noise of the teacher" rather than literally matching.

What would strengthen the experimental case:

• An ablation replacing the exponential momentum parameterization with a learned polynomial velocity profile of equivalent capacity, to isolate whether the exponential form specifically or increased capacity generally drives the gains.
• Evaluation on an additional modality (e.g., text-to-video, molecular generation) to test the generality of the geometric compatibility claim.
• Wall-clock time measurements for the teacher on identical hardware to substantiate the 40× speedup.
• Comparison at 1, 3, and 4 NFEs to characterize how the method degrades at extreme low-step regimes and whether the 2-step setting is a sweet spot or a hard limit.
• A controlled study varying LoRA rank vs. full fine-tuning for all methods to disentangle the effects of parameter-efficient adaptation from the trajectory parameterization itself.

6. Limitations and Trade-offs

6.1 Catastrophic Failure at 1 NFE: The Geometric Compatibility Claim Has a Sharp Lower Bound

The assumption or constraint. ArcFlow's central thesis is that non-linear trajectory parameterization resolves a geometric mismatch that limits linear-step distillation methods. If this were a fundamental property of the momentum mixture — that it can represent the curvature of the teacher's trajectory — one might expect the method to work across a range of step counts, with graceful degradation as NFEs decrease. Instead, the paper explicitly documents a sharp failure mode at 1 NFE:

"when forced to degenerate to the extreme setting of single-step inference (1 NFE), ArcFlow exhibits severe degradation in generation quality and fails to produce meaningful results" (Appendix G).

The authors attribute this to "the difficulty of accurately modeling the momentum factor γ under a 1 NFE regime, where γ becomes highly sensitive and challenging to predict without sufficient modeling capacity."

The consequence. This failure reveals a fundamental tension in the geometric compatibility claim. Theorem 1 guarantees that with K = 16 modes, ArcFlow can exactly match the teacher's velocity at up to 16 distinct timesteps. But at 1 NFE, the model must predict momentum parameters at t = 1 that, when exponentiated over the entire interval [0, 1], produce a trajectory matching the teacher's full 50-step curve — without any intermediate correction. This is a qualitatively harder extrapolation problem than the 2-NFE case (where parameters are re-estimated at t = 0.5), and it apparently exceeds what the current architecture can deliver.

For practitioners, this means ArcFlow does not provide a continuous knob trading off speed and quality below 2 NFEs. If an application requires single-step generation (latency below ~1.4 seconds on Qwen-Image-20B), ArcFlow is not viable. The method occupies a specific operating point (2 NFEs) rather than providing a general few-step solution. This also weakens the theoretical narrative: if the parameterization were truly geometrically compatible with the teacher's trajectory in a deep sense, one might expect it to work with K = 50 modes at 1 NFE, matching velocities at all 50 teacher timesteps through a single predicted curve. The fact that it does not suggests that prediction error in γ (amplified exponentially over the full interval) or insufficient backbone capacity to predict 50-mode mixtures from a single state creates a practical ceiling that Theorem 1's existence guarantee does not address.

What evidence exists in the paper. Figure 9 in Appendix G shows a blurry, severely degraded output at 1 NFE, confirming the failure qualitatively. No quantitative metrics are reported for the 1-NFE case. The paper acknowledges this as a limitation in its own "Limitations and Future Work" section (Appendix G), noting that "a potential direction to address this issue is to design deeper or more expressive network layers dedicated to modeling γ."

Mitigation status. Not addressed. The paper proposes future work on deeper γ-modeling networks but provides no experimental evidence that this would solve the problem. The 1-NFE failure is presented as an open challenge, not a solved or bounded limitation. A practitioner evaluating ArcFlow for deployment must treat 2 NFEs as a hard minimum.

6.2 Difficulty Estimation Cost Is Unaccounted for in Training and Deployment

The assumption or constraint. ArcFlow's training procedure relies on a frozen pre-trained teacher model to provide ground-truth velocity targets at every training step. During the mixed integration curriculum, the teacher must be queried to compute the teacher-phase integration (from t_prev to t_mix in Algorithm 1) and to provide velocity targets at each of the n = 4 intermediate timesteps per interval. The teacher is a large model (20B parameters for Qwen-Image) and each query requires a full forward pass.

This cost is not included in any efficiency calculation. The paper reports training time in terms of student training steps (7,500 for Qwen, 8,000 for FLUX), convergence speed relative to competing methods (Figure 2), and parameter efficiency (<5% of backbone weights trainable). But the total FLOPs or wall-clock time required for training depends on how many teacher forward passes are needed per student update, and this cost is never quantified.

The consequence. The training efficiency claims are incomplete. A training step for ArcFlow requires:

• 1 student forward pass (at t_src to predict momentum parameters)
• n teacher forward passes (at each intermediate t_i for velocity matching targets)
• n teacher forward passes during mixed integration (at each t_prev to compute teacher-phase velocities, though the paper notes this can use cached velocities since sub-intervals are small — Appendix C.1)

For n = 4 intermediate timesteps (Table 6), this means approximately 4–8 teacher forward passes per student update, depending on implementation. Since the teacher is roughly the same size as the student (same architecture except for LoRA adapters), the teacher's forward pass is comparable in cost to the student's. The effective training cost per step is thus multiples of what the "student training steps" metric suggests.

In deployment, a related cost appears: the paper never discusses whether the momentum mixture parameterization introduces inference-time overhead from the analytic solver or the additional projection heads. Table 8 (Appendix F.3) provides inference time measurements showing ArcFlow at ~1.4s, which is competitive with fully-fine-tuned baselines — but these measurements don't isolate the cost of computing the analytic transition operator Φ, evaluating K = 16 exponential terms, or the additional projection head computations. The claim that these costs are "negligible" is plausible (O(K) scalar operations vs. O(D²) transformer operations) but not empirically verified through an ablation that measures inference time with and without the momentum heads.

What evidence exists in the paper. The paper does not report total training FLOPs, total teacher queries per training run, or an ablation measuring the inference-time cost of the momentum components. Table 8 provides end-to-end inference times but no breakdown. Figure 2 compares convergence across methods but all are trained on identical hardware — the comparison is fair if all methods have similar per-step costs, but the paper doesn't verify this assumption.

Mitigation status. Not addressed. The paper does not acknowledge this as a limitation. For a practitioner who needs to budget training compute, the missing teacher-query cost is a significant gap in the reported efficiency analysis. The claim of "4× faster training convergence" (Section 1) is based on FID vs. training iterations, not wall-clock time or total FLOPs, and the latter metric would be less favorable if ArcFlow's per-iteration cost is higher due to teacher queries.

6.3 Single-Task, Single-Modality Evaluation Limits Generality Claims

The assumption or constraint. All experiments in the paper are conducted on text-to-image generation using two specific model families (Qwen-Image-20B and FLUX.1-dev) evaluated on three standard T2I benchmarks (Geneval, DPG-Bench, OneIG-Bench) plus the custom Align5000 dataset. The method is motivated by general properties of flow matching and probability flow ODEs — concepts that apply to any continuous-time generative model — but the empirical validation is restricted entirely to image generation with large Transformer backbones.

The paper makes claims about generality in its conclusion:

"We believe ArcFlow highlights the importance of respecting the underlying flow dynamics for efficient generative inference."

This language implies that the findings apply beyond the tested domain, but no evidence supports this extrapolation.

The consequence. Several aspects of ArcFlow's design may not transfer to other modalities or model scales:

• The momentum mixture parameterization assumes that velocity evolution follows an exponential decay/growth law. In image generation with flow matching (which typically uses linear interpolation paths between noise and data), this may be a reasonable approximation because the dynamics are relatively smooth. In other domains — molecular conformer generation, audio synthesis, video prediction — the velocity field may exhibit non-monotonic behavior, sharp transitions, or multi-scale dynamics that an exponential mixture cannot capture well.

• The K = 16 mode setting was empirically tuned on Qwen-Image-20B (Table 5). For smaller models, 16 modes may be excessive (overfitting, wasted capacity); for larger models or more complex data manifolds, 16 may be insufficient. The paper provides no guidance on how to select K for a new domain short of running a full sweep.

• The mixed integration curriculum depends on the teacher providing reliable velocity targets at intermediate timesteps. This assumes the teacher's velocity predictions are well-calibrated at all timesteps — a property that holds for the high-quality teachers used (Qwen-Image, FLUX) but may not for weaker teachers or teachers trained with different objectives.

• The benchmark evaluation focuses on prompt-alignment and distributional fidelity metrics (FID, CLIP, Geneval, DPG-Bench). These metrics capture important properties but are not comprehensive. For instance, they don't evaluate fine-grained spatial reasoning, attribute binding, or compositional generalization — all of which are known weaknesses of few-step distilled models and which the qualitative results in Figures 4 and 10 hint may still be issues (some images show structural artifacts, though less than competitors).

What evidence exists in the paper. None beyond the image generation domain. The paper does not include experiments on other modalities, other model architectures (e.g., U-Net-based diffusion models, smaller DiT variants), or other data types. The two backbones are both large-scale Transformer-based flow matching models, which may share properties (smooth velocity fields, similar noise schedules) that make them amenable to ArcFlow in ways that other models are not.

Mitigation status. Not addressed. The paper does not claim evaluation on other modalities as future work. A practitioner considering ArcFlow for a non-image domain (e.g., video, audio, molecular dynamics) has no empirical evidence that the method will transfer, despite the general formulation in the method section. The theoretical guarantees (Theorem 1) are domain-agnostic, but theory only guarantees representational capacity, not that the training procedure will successfully learn the momentum parameters for a given domain's velocity field characteristics.

6.4 Weak 1-NFE Baselines and Missing Controlled Ablations Undermine Causal Attribution

The assumption or constraint. The paper's central claim is that non-linear trajectory parameterization — specifically, the exponential momentum mixture with analytic integration — is the causal factor driving ArcFlow's performance advantages over competing methods. The experiments are designed to show that ArcFlow outperforms pi-Flow, TwinFlow, and Qwen-Image-Lightning, but they do not provide the controlled comparisons needed to isolate the non-linear parameterization from other confounding variables.

Specifically:

• The competing methods use different training paradigms (adversarial objectives for Lightning and TwinFlow, policy imitation for pi-Flow) and different parameter budgets (full-model fine-tuning for TwinFlow and pi-Flow vs. LoRA for ArcFlow). Performance gaps could be attributed to the training objective, the optimization stability, or the parameter efficiency rather than the trajectory geometry.

• There is no ablation replacing the exponential momentum parameterization with an alternative non-linear form of equivalent capacity. For example, a learned polynomial velocity profile v(t) = Σ a_k t^k with the same number of parameters (K coefficients per mode) and analytic polynomial integration would test whether the exponential form specifically matters or whether any non-linear parameterization with sufficient capacity would work.

• The convergence comparison (Figure 2) uses batch size 16, while full training uses batch size 384 (Table 6). Adversarial methods (TwinFlow, Lightning) are known to be sensitive to batch size because larger batches provide more stable discriminator gradients. The convergence gap at batch size 16 may exaggerate ArcFlow's advantage relative to what would be observed at production-scale batch sizes.

• ArcFlow uses a different training dataset (the pi-Flow 2.3M prompt dataset) from what TwinFlow and Lightning were originally trained on. While the paper retrains pi-Flow and TwinFlow on the same dataset for the convergence comparison, the training hyperparameters (learning rate, optimizer settings, training schedule) were designed for ArcFlow and may not be optimal for the competing methods. The paper does not report hyperparameter tuning effort for the baselines.

The consequence. The causal story — "non-linear trajectories enable parameter-efficient, fast-converging distillation" — is correlational, not causally established. An alternative explanation consistent with all reported results is: "ArcFlow benefits from (a) increased velocity parameter count via K = 16 modes, (b) a stable L2 velocity-matching objective that avoids adversarial instability, and (c) LoRA fine-tuning that prevents overfitting and enables better reuse of teacher features. The exponential form and analytic integration provide modest additional benefits but are not the dominant drivers of performance."

Without the missing controlled ablations (e.g., linear-step student with LoRA and equivalent parameter count, or a non-linear-exponential student with adversarial objectives), the relative importance of the architectural innovation vs. the training methodology cannot be determined.

What evidence exists in the paper. The ablation on γ (Table 3) shows that removing the momentum factor (γ ≡ 1) degrades FID from 14.56 to 17.06, confirming that the exponential form matters. But this doesn't test whether an alternative non-exponential form would work. The ablation on (N_v, N_γ) configurations (Table 4) shows that decoupling velocity and momentum diversity helps, but this is consistent with increased parameter count being the primary driver. The ablation on K (Table 5) shows diminishing returns, consistent with capacity saturation rather than geometric compatibility being the limiting factor at K = 16.

Mitigation status. Not addressed. The paper does not acknowledge the confounding variables or propose the missing controlled experiments. The convergence and parameter-efficiency claims are presented as direct consequences of geometric compatibility without ruling out alternative explanations. This is the most significant methodological weakness for a reader trying to understand why ArcFlow works, as opposed to whether it works (which the benchmarks establish).

6.5 The Revision Model Analogue Is Absent: Only Velocity Field Distillation, Not Proposal Distribution Improvement

The assumption or constraint. ArcFlow exclusively addresses what the earlier reference example would call the verifier/selection axis of test-time compute — it improves how the student selects its trajectory through the velocity field. It does not address the proposal distribution axis — improving what candidates the model generates by conditioning on previous attempts. Specifically, ArcFlow distills the teacher's velocity field into a 2-step process but does not explore whether the student could benefit from iterative refinement: generating an initial 2-step image, evaluating it (via a verifier or self-assessment), and then applying additional computation to improve it.

This is relevant because the paper motivates its approach by analogy to physics and trajectory dynamics, but never considers whether the 2-step limitation could be circumvented entirely by allowing the model to take more steps only when needed — a compute-adaptive approach. The 2-NFE setting is treated as a fixed constraint rather than a point on a trade-off curve.

The consequence. ArcFlow commits to a fixed inference budget of 2 NFEs for all prompts. The paper's own qualitative results (Figures 4, 10, 11) show that even with 2 NFEs, some images exhibit residual artifacts — subtle blur, structural imperfections, or prompt-misalignment on complex scenes — that a prompt-adaptive budget could potentially correct. Methods like the one described in the reference example (adaptive test-time compute allocation based on difficulty estimation) could use ArcFlow as the base 2-step generator and then apply extra steps or search only on hard prompts, trading average latency for worst-case quality. ArcFlow provides no mechanism for this.

Additionally, the absence of a revision mechanism means the student cannot self-correct. If the 2-step generation produces an image with visible flaws (e.g., the bent swords in Figure 4, second column, or the blurred background in the third column for competing methods, though ArcFlow shows fewer such issues), there is no way to refine the output without starting over. This is a fundamental limitation for applications requiring high reliability per sample.

What evidence exists in the paper. None. The paper does not discuss revision, adaptive compute, or quality-latency tradeoffs beyond the fixed 2-NFE setting. The limitation section (Appendix G) only discusses the 1-NFE degradation. The convergence visualization (Appendix F.2) shows that early-training ArcFlow images are "over-smoothed," but the final model still produces some images with subtle quality issues (visible in the qualitative comparisons, though less severe than competitors).

Mitigation status. Not addressed. The paper positions 2-NFE generation as the end goal rather than a point on a broader efficiency-quality Pareto frontier. A practitioner who wants the flexibility to trade additional inference time for higher quality on specific challenging prompts cannot do so with ArcFlow as presented. This is a design choice, not an oversight — the paper's goal is fast generation — but it limits the method's applicability in settings where quality requirements are strict and some prompts may need more than 2 steps.

6.6 The 40× Speedup Figure Is Not Directly Measured and the 2-NFE Operating Point May Not Be Generally Optimal

The assumption or constraint. The paper's headline efficiency claim is a 40× speedup over the multi-step teacher. However, this figure appears to be derived from NFE count rather than directly measured wall-clock time:

• The teacher Qwen-Image-20B uses 50 steps with Classifier-Free Guidance (CFG), which requires two forward passes per step, hence 100 total NFEs. ArcFlow uses 2 NFEs. The ratio 100/2 = 50× in terms of network evaluations.
• The paper reports 40× rather than 50×, likely to account for overhead or approximation, but no wall-clock time measurement of the teacher is provided to substantiate this. Appendix F.3 reports student inference times (Table 8) but does not include teacher inference times on the same hardware.

Without a direct measurement, the actual speedup could be less than 40× if the teacher benefits from compute optimizations not available to the student (e.g., CUDA kernel fusion for standard DiT blocks vs. the LoRA-modified student) or more than 40× if the CFG overhead is larger than estimated. The paper also does not specify whether the 40× refers to latency (wall-clock time per image) or throughput (images per second in batch processing) — these can differ substantially depending on GPU utilization and memory bandwidth.

The consequence. The 40× speedup is a marketing figure, not an engineering measurement. A practitioner trying to estimate the actual latency improvement in their deployment environment cannot do so from the paper's reported data. They would need to benchmark both teacher and student on their specific hardware, at their specific batch size and resolution, with their specific precision settings. The paper provides some of the needed data (student inference times: ~1.4s for 1024×1024 on unspecified hardware) but not the teacher baseline.

Additionally, the paper never explores whether 2 NFEs is the optimal operating point on the quality-vs-speed trade-off. The ablations focus on architectural choices (K, γ settings, curriculum) rather than the NFE count. Table 5 shows diminishing returns from K = 16 to K = 32 at 2 NFEs, but this doesn't tell us whether 3 or 4 NFEs with K = 16 would yield substantially better quality at acceptable latency, or whether 2 NFEs leave meaningful quality on the table relative to 3–4 NFEs. The 1-NFE failure case suggests there is a sharp cliff between 1 and 2 NFEs, but the paper doesn't characterize the region above 2 NFEs.

What evidence exists in the paper. Table 8 provides inference times for the 2-NFE students (~1.37–1.72s for Qwen-based methods) but not for the teacher. The 40× claim appears in the abstract, introduction, and conclusion but is never substantiated with a wall-clock measurement or precise calculation. The paper states in the abstract that ArcFlow "achieves a 40× speedup with 2 NFEs over the original multi-step teachers" but the experiments section only reports NFE counts and inference times for students.

Mitigation status. Not addressed. The paper does not provide teacher inference time measurements, does not specify the hardware used for the speedup calculation, and does not clarify whether the 40× refers to latency or throughput. The "less than 5% parameters" claim (Section 1) is well-substantiated, but the complementary speedup claim is imprecise. For a paper whose primary contribution is accelerating inference, this is a significant omission that a practitioner would want resolved before making deployment decisions based on the 40× figure.

A final note on the 2-NFE operating point: the paper's convergence comparison (Figure 2) suggests ArcFlow reaches near-asymptotic performance quickly (by ~3K steps). If additional training or architectural improvements could push performance at 1 NFE, or if 3–4 NFEs would provide substantial quality improvements at modest latency cost, the paper provides no guidance. A practitioner is left with a single recommended configuration (2 NFEs, K = 16, mixed integration for 1000–2000 steps) without understanding the sensitivity of results to these choices.

7. Implications and Future Directions

How This Work Changes the Landscape

ArcFlow introduces a diagnostic reframing rather than a paradigm shift. It does not propose a new class of generative models, a new learning algorithm, or a new theoretical framework for diffusion. Instead, it changes how the field should think about the few-step distillation problem: from an optimization challenge ("how do we train students to compress many teacher steps into few?") to a representational geometry challenge ("can the student's parameterization even represent the shape of the teacher's trajectory?").

The magnitude of this shift is moderate but catalytic. It is moderate because the core technique — exponential parameterization with analytic integration — is a specific architectural choice, not a universal principle. Other distillation paradigms (consistency models, adversarial distillation, progressive distillation) remain viable and are not rendered obsolete. But it is catalytic because it provides a unifying explanation for failure modes that previously seemed disconnected:

• Why progressive distillation degrades at very low NFEs: The trajectory cannot be straightened sufficiently; residual curvature exceeds what linear steps can absorb (Section 2).
• Why adversarial methods suffer mode collapse: The discriminator penalizes distribution mismatch but cannot correct the student's geometric inability to reach certain regions of the teacher's distribution via straight-line paths. The student collapses to modes it can reach (Table 1: Qwen-Image-Lightning loses 85.7% relative Diversity compared to ArcFlow).
• Why full-parameter fine-tuning is necessary for linear methods: The teacher's features are optimized for a 50-step regime where each prediction is a single-timestep velocity. A 2-step linear student needs fundamentally different features to predict velocities that serve as multi-step chords. The features must be overwritten, which is why TwinFlow and pi-Flow require full-model training while ArcFlow converges with less than 5% of parameters (Figure 2, Table 6).
• Why adversarial objectives exist at all in distillation: They compensate for the distribution shift that occurs when a geometrically mismatched student drifts off the teacher's manifold. ArcFlow largely avoids this by keeping the student's trajectories geometrically compatible with the teacher's, eliminating the need for a discriminator.

This reframing reconciles prior contradictions in the distillation literature. Earlier work oscillated between optimism ("we can train 1-step models with adversarial losses!") and pessimism ("few-step models lose detail and diversity"). ArcFlow shows that both perspectives were correct for different reasons: adversarial methods can produce sharp images at 1–2 steps, but they lose distributional fidelity because they patch over a geometric problem with a statistical objective. The geometric mismatch remains, and it manifests as mode collapse and detail degradation measured by FID/pFID even when prompt-alignment scores look competitive (the Qwen-Image-Lightning vs. ArcFlow comparison in Tables 1 and 2 exemplifies this split). ArcFlow resolves the contradiction by showing that when the student's parameterization is geometrically compatible with the teacher's trajectory, you get both sharp images and high distributional fidelity, without needing adversarial training.

Research directions that become more attractive after this work:

• Studying the representational capacity of student parameterizations as a first-order design consideration, on equal footing with loss function design and training data. The paper effectively argues that you should ask "can my student represent the teacher's trajectory shape?" before asking "how should I train my student?"
• Exploring alternative non-linear velocity parameterizations that share ArcFlow's key properties (analytic integrability, temporal structure, mixture decomposition) but with different functional forms (polynomial, rational, spline-based). The paper opens a design space where the exponential form is one point.
• Theoretical analysis of geometric compatibility as a formal property. What metric quantifies the gap between a student's trajectory hypothesis space and the teacher's reference trajectory? Can this gap predict downstream FID/pFID without running full training?
• Parameter-efficient distillation more broadly. ArcFlow shows that LoRA-scale adaptation is sufficient when the geometric fit is right. This suggests that many distillation methods may be over-parameterized — they use full-model training not because it's necessary for capacity, but because it's necessary to compensate for representational mismatch.

Research directions that become less attractive:

• Incremental improvements to adversarial distillation objectives for few-step image generation. If the root cause of mode collapse and detail loss is geometric mismatch, then better discriminators or more stable GAN training will provide diminishing returns compared to fixing the underlying trajectory representation. The paper's demonstration that a simple L2 velocity-matching loss outperforms sophisticated adversarial methods (TwinFlow, Lightning) when paired with a compatible parameterization is evidence for this.
• Progressive distillation as a standalone path to 1–2 step models. The paper's geometric argument implies that progressive halving will always leave residual curvature at very low NFEs, making it a fundamentally limited approach regardless of how many rounds are applied. Further rounds of progressive distillation below 2–4 steps are likely to hit a geometric wall that no amount of training can overcome.

A crucial boundary condition the paper establishes: the geometric compatibility approach has a sharp lower limit at 2 NFEs. The failure at 1 NFE (Appendix G, Figure 9) means ArcFlow does not provide a continuous quality-speed Pareto frontier — it works at 2 steps and above, but collapses at 1 step. This distinguishes it from methods that degrade gracefully (even if to low quality) at extreme step counts. A practitioner must treat 2 NFEs as a hard minimum for ArcFlow, which constrains the minimum achievable latency to roughly the numbers in Table 8 (~1.4s at 1024×1024).

Follow-Up Research This Work Enables

Characterizing the 1-NFE failure mode and whether it is fundamental or architectural. ArcFlow produces severely degraded outputs at 1 NFE (Appendix G), attributed to the sensitivity of γ prediction over the full [0,1] interval. A natural follow-up would systematically study: does the failure arise from (a) insufficient K (not enough modes to represent the full-trajectory curvature from a single state), (b) γ prediction instability (small log-γ errors exponential-amplified over the full interval), or (c) insufficient backbone capacity to predict 16-mode mixtures from pure noise? The experiment would sweep K ∈ {16, 32, 64, 128} at 1 NFE, measure FID, and examine whether performance saturates at some K (indicating a representational limit) or fails to improve at all (indicating optimization or γ instability as the bottleneck). If it's a representational limit, Theorem 1 suggests K would need to match the teacher's step count (~50 for exact matching), which may be architecturally infeasible. If it's γ instability, techniques like γ regularization, multi-scale γ prediction, or hybrid linear-exponential modes might help. This experiment would determine whether 1-NFE distillation via non-linear trajectories is fundamentally hard or merely requires better engineering of the γ prediction head.

Replacing the exponential parameterization with alternative analytically integrable velocity profiles. The paper demonstrates that non-linear trajectory parameterization matters, but does not establish that the exponential form is uniquely suitable. A controlled study would benchmark ArcFlow against variants replacing the exponential basis γ_k^{1-t} with (a) polynomial basis Σ_{j=0}^d a_{k,j} t^j (analytically integrable as a sum of monomials, with the same parameter budget K × (d+1)), (b) Fourier basis on [0,1] (also analytically integrable, potentially better for oscillatory dynamics), and (c) learned monotonic splines. All variants would use the same training procedure (mixed integration curriculum, L2 velocity matching, LoRA adapters), the same K, and the same parameter count. The key metric would be FID vs. training steps, to test whether the exponential form specifically or increased velocity capacity generally drives ArcFlow's gains. A negative result (all non-linear forms perform similarly) would strengthen the geometric compatibility narrative while showing exponential is not special; a positive result (exponential uniquely effective) would motivate deeper theoretical study of why exponential decay captures denoising dynamics so well.

Extending ArcFlow to text-to-video and other temporally-structured generative domains. The momentum parameterization models velocity evolution over denoising time t, not over physical time in a video. However, video diffusion models have an additional temporal dimension (frame index) that interacts with denoising time. A natural question: can ArcFlow's momentum mixture be extended to model velocity evolution over both denoising time and frame index, enabling few-step video generation with comparable fidelity gains? The experiment would take a pre-trained text-to-video flow matching model, apply ArcFlow distillation with K modes, and evaluate on standard video benchmarks (UCF-101, MSR-VTT) comparing FVD (Fréchet Video Distance) against linear-step baselines at 2–4 NFEs. If ArcFlow's gains transfer, this would validate the geometric compatibility claim as domain-general rather than image-specific. A negative result would suggest that video velocity fields have different smoothness properties or that the exponential assumption breaks down when physical time and denoising time interact.

Training a difficulty predictor to enable adaptive NFE allocation with ArcFlow. ArcFlow operates at a fixed 2 NFEs for all prompts, but the paper's qualitative results show that some complex prompts still exhibit subtle artifacts (visible in Figures 4, 10, 11) while simple prompts may be over-processed at 2 NFEs. A follow-up would train a lightweight classifier on top of ArcFlow's intermediate latent x_0.5 (after the first NFE) to predict whether the final x_0 will be high-quality (e.g., via CLIP score or a learned quality metric). For prompts predicted as "hard," ArcFlow could dynamically revert to 3–4 NFEs or fall back to the teacher. The metric would be average inference time on a benchmark with a quality floor (e.g., ensure 95% of images exceed a CLIP threshold, minimize average NFE). This would address one of ArcFlow's key limitations — the fixed 2-NFE budget — by enabling compute-adaptive deployment. The experiment would build on the paper's existing infrastructure (the student already produces x_0.5, which encodes trajectory information) and would directly test whether the geometric compatibility property makes intermediate states more informative for difficulty prediction than linear-step intermediates.

Investigating whether LoRA-based adaptation generalizes across teacher architectures. ArcFlow shows that LoRA-scale fine-tuning suffices for distilling Qwen-Image-20B and FLUX.1-dev, two large Transformer-based flow matching models. An open question is whether this efficiency transfers to (a) U-Net-based diffusion models (e.g., Stable Diffusion 3.x, which uses a different backbone), (b) smaller models where LoRA may not have enough capacity to learn the momentum mixture, or (c) much larger models where the teacher's features may be more rigid. A systematic study would apply ArcFlow to a range of model architectures and scales (U-Net 2B, DiT 7B, DiT 20B, DiT 30B+), keeping K = 16 and the LoRA rank fixed, and measure whether FID relative to the teacher degrades at the extremes. A finding that LoRA efficiency is constant across scales would suggest that geometric compatibility is a universal property of flow matching trajectories, independent of architecture. A finding that larger models require higher LoRA rank or full fine-tuning would bound the scalability of the approach and suggest that at extreme scales, even geometrically compatible parameterizations need more capacity to adapt the teacher's rigid features.

A negative-result experiment: stress-testing the Chebyshev completeness guarantee in practice. Theorem 1 proves that with K modes, ArcFlow can match the teacher's velocity at K timesteps — but this is an existence proof, not a learnability proof. A valuable negative result would test whether the theorem's promise holds under realistic optimization. The experiment: for a fixed model and prompt, (a) run the 50-step teacher to record ground-truth velocities at all 50 timesteps, (b) train an ArcFlow student with K = 50 modes exclusively on those 50 velocity targets (supervised, no mixed integration), and (c) measure the L2 reconstruction error of the student's predicted velocities vs. the teacher's at all 50 timesteps. If the error is near zero, the theorem is practically realizable and the 1-NFE failure must be due to extrapolation from pure noise, not representational insufficiency. If the error remains non-zero even with K = 50, the theorem's existence guarantee masks an optimization hardness problem — the parameters exist but gradient descent cannot find them — which would fundamentally bound ArcFlow's achievable fidelity. This experiment would clarify whether future work should focus on better optimization (to find the guaranteed parameters) or better parameterizations (because the exponential form, while complete in theory, is ill-conditioned in practice).

Practical Applications and Downstream Use Cases

On-device or edge deployment of large text-to-image models. ArcFlow reduces a 20B-parameter teacher from 100 forward passes (50 steps × 2 CFG) to 2 forward passes, with only negligible additional overhead from the momentum heads. The resulting inference time of ~1.4s at 1024×1024 (Table 8) brings large-model image generation into the realm of consumer-grade GPUs and potentially high-end mobile devices. For application developers building creative tools, real-time image editing interfaces, or on-device generation features, ArcFlow's parameter efficiency is particularly valuable: the LoRA adapter weights (less than 5% of the backbone) can be distributed as a small add-on to a shared base model, reducing download sizes and enabling quick model switching. A photo editing app could ship the frozen Qwen-Image-20B backbone once (20B parameters, ~40GB) and offer multiple ArcFlow-LoRA variants (style-specific, resolution-specific, aspect-ratio-specific) as lightweight downloads (~400MB each based on rank-256 LoRA on ~5% of parameters). This is a concrete deployment advantage over full-parameter distillation methods, which require distributing the entire 20B model for each variant.

Cost-efficient batch image generation for synthetic data pipelines. Organizations generating large volumes of synthetic images for training downstream models (object detection, segmentation, data augmentation) currently face a trade-off: use multi-step models for quality (50 NFEs per image, high cost) or few-step models for throughput (lower quality, risk of distribution shift affecting downstream task performance). ArcFlow's combination of 2-NFE speed and high teacher-alignment fidelity (FID 12.40 vs. teacher, pFID 3.78 for Qwen; Table 2) makes it a strong candidate for this use case. At a throughput of ~0.7 images per second per GPU (1/1.411s from Table 8), a single H100 can generate ~60,000 images per day. The high pFID score specifically indicates that local textures and fine details — critical for downstream models that rely on these features — are well-preserved. This is in contrast to Qwen-Image-Lightning, which achieves competitive prompt-alignment scores but substantially worse pFID (11.32 vs. ArcFlow's 3.78), meaning its images may look correct at a glance but contain texture artifacts that degrade downstream model performance. A concrete deployment scenario: a robotics company generating 1M synthetic training images for a grasping model would need ~17 GPU-days with ArcFlow vs. ~680 GPU-days with the 50-step teacher — a 40× cost reduction without the fidelity penalty that cheaper 2-step alternatives (Lightning, pi-Flow) impose.

Interactive creative tools requiring low-latency iteration. Applications like real-time image generation from text prompts (where users iteratively refine prompts and see results immediately) require sub-2-second latency to feel responsive. ArcFlow's ~1.4s inference time at 1024×1024 meets this threshold, while the teacher (at an estimated 28–56 seconds, scaling from the 40× claim) would be unusable for interactive use. Crucially, ArcFlow preserves generation diversity (Diversity 0.182 on OneIG-Bench vs. Lightning's 0.098; Table 1), meaning users exploring a creative space by re-generating with different random seeds will see genuinely different images rather than mode-collapsed variations. This is essential for creative workflows where exploration is the goal. A tool like an AI-assisted concept art generator could use ArcFlow-Qwen as the default engine, falling back to the 50-step teacher only for highly complex prompts that exceed ArcFlow's capability envelope — a hybrid deployment that the paper's infrastructure naturally supports since the student and teacher share the same backbone architecture.

Self-improvement and distillation pipelines where training cost matters. If a research team wants to iteratively improve a text-to-image model through cycles of generation, filtering, and fine-tuning (a self-improvement loop), the generation step is often the computational bottleneck. ArcFlow's training efficiency becomes directly relevant here: new ArcFlow variants can be distilled for each iteration of the loop in ~7,500 steps (Table 6), which with batch size 384 and 96 H100 GPUs translates to roughly hours of training rather than days. The fast convergence (Figure 2: competitive FID at 1K steps) means that even rapid prototyping cycles (testing different K values, momentum initializations, or curriculum schedules) can be done on modest compute budgets — run for 1K–2K steps, evaluate FID, and iterate. This dramatically lowers the barrier to entry for research groups without access to massive compute clusters to experiment with few-step distillation. More broadly, the parameter-efficient adaptation strategy means that a single pre-trained teacher checkpoint can be distilled into many specialized ArcFlow variants (for different resolutions, aspect ratios, or style domains) with minimal storage overhead — each variant is a LoRA adapter, not a full model copy.