ArXiv: 2602.24289

🎯 Pitch

Training a video model on both short and long clips creates destructive gradient interference, forcing a choice between crisp local detail or long-term coherence—but this work shows that routing them through decoupled heads (Flow Matching for global structure, a mode-seeking reverse-KL loss for local fidelity) resolves the conflict, allowing a few-step generator to produce minute-long videos that inherit the sharpness of a frozen short-video teacher while preserving narrative consistency learned from scarce long-form data.

1. Executive Summary

This paper proposes a training paradigm called Mode Seeking meets Mean Seeking that decouples local fidelity from long-term coherence for minute-scale video generation, using Wan 1.3B and 14B models as both student and teacher. The approach employs a Decoupled Diffusion Transformer with two separate heads — a Flow Matching head trained via supervised learning on scarce long videos to capture global narrative structure (mean-seeking toward real long-clip targets), and a Distribution Matching head that aligns every sliding-window segment of the student's output to a frozen short-video teacher via a mode-seeking reverse-KL divergence (using DMD/VSD-style gradients on on-policy rollouts) — resolving gradient interference through decoupled objectives that share a unified long-context encoder. On 30-second video generation evaluated against VBench-Long metrics and Gemini-3-Pro consistency scoring, the method closes the fidelity–horizon gap, jointly improving local sharpness, motion quality, and long-range consistency over both SFT-only baselines (which produce blurry outputs) and teacher-only autoregressive methods (which suffer from drift, static content, or over-saturation), establishing that local realism can be inherited from a short-video teacher without requiring additional short-video data only when global coherence is simultaneously anchored through supervised flow matching on real long-form clips and the two signals are routed through separate heads.

2. Context and Motivation

The Core Problem: Long Videos Are Not Just Longer Short Videos

The paper addresses a fundamental scaling problem in generative video modeling. While the field has made rapid progress on short video generation — producing high-fidelity clips typically lasting 5–10 seconds — extending these systems to minute-scale generation confronts a bottleneck that is qualitatively different from what the image generation community faced when scaling resolution. The authors crystallize this insight in Figure 1: the temporal dimension is not analogous to image resolution. A 1024×1024 image is an interpolation of a 256×256 image — the underlying patch distribution remains essentially the same, just sampled at a finer grid. A one-minute video, however, is not an "interpolation" of a 5-second video; it is an "extrapolation" that introduces new events, causal chains, and narrative structure. In the authors' framing:

"A one-minute video, however, is not an 'interpolation' of a 5-second video: it is an 'extrapolation' that adds new events, causal chains, and narrative structure, encoding substantially more information."

This distinction is crucial because it means that training strategies that worked for multi-resolution image generation — notably, training a single model on a "soup" of different-length videos — implicitly rely on an interpolation assumption that fails for long-form content. The model must explicitly learn temporal dependencies that span orders of magnitude longer than what short clips can teach.

Why This Problem Matters

The paper identifies several downstream applications that depend on solving the long-video generation challenge. Interactive world modeling for embodied agents and games requires persistent, coherent environments that evolve over extended time horizons. Long-form story or film generation demands that characters, scenes, and causal sequences remain consistent across minutes rather than seconds. Controllable video editing and animation needs identity and style to be maintained across extended temporal windows. These are not marginal extensions of short-video generation — they are qualitatively different capabilities that the current generation of models cannot reliably deliver.

The practical urgency of this problem is compounded by a stark asymmetry in data availability:

"seconds-long clips are abundant online and thus available at web scale... High-quality long-form videos that are minute-scale sequences with sustained events and context are far scarcer at a comparable scale, more heterogeneous, and substantially more expensive to curate and filter."

This data scarcity is not a temporary inconvenience but a structural constraint. Long-form videos with sustained narrative coherence — single-shot sequences where the camera follows a subject through continuous action, or scenes that unfold with causal complexity — are inherently rarer than short clips because they require more planning, production effort, and storage. The inference-time cost of training on such data is also substantially higher, since the computational demands of video diffusion models scale with sequence length. The core tension is therefore: the strongest available prior over realistic short-timescale dynamics lives in a short-video generator that has already been trained on web-scale diversity and refined extensively, while long-video training must operate in a much more data-constrained and computationally expensive regime.

Where Existing Approaches Fall Short

The paper organizes prior work along several axes and identifies specific failure modes for each.

The "Video Length Soup" Approach

A widely adopted industrial practice — used in systems like HunyuanVideo (Kong et al., 2024), CogVideoX (Yang et al., 2024), and Seedance (Seawead et al., 2025) — is to train a single model on videos of varying durations, hoping that the model smoothly interpolates across temporal horizons just as image models interpolate across spatial resolutions. The authors argue this assumption is fundamentally flawed because it conflates interpolation with extrapolation. The paper provides evidence in the experimental section (Section 4.2) that such mixed-length training, while a robust baseline for establishing temporal coherence, is "fundamentally capped by the scarcity of high-quality training data." The outputs from these methods exhibit a characteristic loss of local realism: fine textures are washed out, edges appear softened, and foreground subjects can collapse into under-defined silhouettes (Figure 4). The authors attribute this to the mean-seeking nature of the flow-matching objective — when trained on scarce long-video data, the model is forced to average away high-frequency detail that was well-captured by the short-video teacher, essentially "relearning a high-fidelity short-video prior from a regime where the data and compute are most constrained."

Teacher-Only Autoregressive Methods

A complementary line of work attempts to extend short-video models to long horizons through autoregressive rollouts, often combined with distillation from a teacher model. Methods like CausVid (Yin et al., 2025), Self-Forcing (Huang et al., 2025b), and InfinityRoPE (Yesiltepe et al., 2026) exemplify this approach. These methods face a distinct set of challenges:

  • Error accumulation in AR rollouts: Slight deviations in early frames compound over dozens of autoregressive steps, leading to significant quality degradation over minute-scale generation. This is a well-known pathology of autoregressive generation that becomes particularly severe when each step is itself a diffusion process operating in high-dimensional video latent space.

  • Fundamental blindness to long-range context: The short-video teacher that these methods distill from is, by construction, trained only on ~5-second clips. It has no concept of what should happen 30 seconds into a sequence — no understanding of narrative arcs, causally extended events, or scene transitions that unfold over minute-scale horizons. As the authors put it:

"a short-video teacher is strictly 'blind' to long-context concepts."

  • Specific artifacts: The paper observes that sink-based methods like InfinityRoPE tend to generate static or nearly frozen content, as reflected by low dynamic degree scores in the quantitative evaluation (Table 1). The mechanism appears to be that attaching generation to sink frames prevents autoregressive drift but at the cost of suppressing motion entirely — a classic exploitation-avoidance tradeoff.

  • Quality-saturation tradeoff: CausVid and Self-Forcing inherit stronger local contrast from the short-video teacher, but this can manifest as over-saturation and reduced temporal dynamics, or as visually stable but eventless sequences designed to avoid the compounding errors that ruin fidelity.

Training-Free Extrapolation Methods

A separate class of approaches attempts to extend pretrained short-video models beyond their training horizon without additional training, through techniques like noise rescheduling (FreeNoise; Qiu et al., 2024), temporal-frequency rebalancing (FreeLong; Lu et al., 2025a), or positional embedding modifications (Riflex; Zhao et al., 2025). These methods work by modifying the inference process of a frozen short-video model to produce longer outputs than it was trained for. The critical limitation is straightforward: the model has no training signal for long-range temporal structure. Noise rescheduling can produce seemingly smooth transitions, but the model lacks any understanding of how events should causally relate across the extended timeline. The resulting videos often exhibit semantic drift, where later frames become progressively disconnected from early frames in terms of object identity, scene layout, or causal consistency.

The Unified Failure Mode: A Signal Conflict

Beneath these specific architectural differences, the paper identifies a deeper, unifying problem. The flow-matching objective commonly used in video diffusion models — minimizing L2L_2 distance between predicted and ground-truth velocities — is fundamentally a mean-seeking objective. It learns the conditional expectation of the velocity field, which, under data scarcity and ambiguity, tends to average over possible futures, producing conservative, blurry outputs. This is acceptable (and even desirable) for short clips where the data distribution is dense enough that the mean is sharp. But when the same objective is applied to long videos with scarce training data, it systematically washes out detail.

What the model needs instead for local fidelity is a mode-seeking signal — one that pushes the output toward sharp, high-probability modes of the teacher distribution, even if that means committing to a particular high-fidelity realization rather than averaging over many possible ones. The reverse-KL divergence (DKL(q∥p)D_{\text{KL}}(q \| p)) is explicitly mode-seeking: it penalizes the student qq heavily if it places mass where the teacher pp has low density, encouraging the student to concentrate on the teacher's high-density regions. Applying both signals — a mean-seeking flow-matching loss on long videos and a mode-seeking teacher alignment loss on sliding windows — to a single velocity predictor produces gradient interference: the supervised objective says "average under uncertainty," while the teacher alignment says "commit to a high-fidelity mode." The model cannot simultaneously satisfy both commands through a single output head.

How This Paper Positions Itself

The paper's central thesis emerges directly from this analysis: local fidelity and long-term coherence should be decoupled because they are optimized by fundamentally different types of loss signals, and the data that supports each is distributed asymmetrically between short and long videos.

The proposed framework can be understood as a division of labor between three components:

  1. A shared long-context encoder that processes the full noisy long-video latent with full-range temporal attention, building representations that encode global structure. This encoder is updated by both signals, so it learns representations that serve both objectives.

  2. A mean-seeking Flow Matching head trained on real long videos via supervised flow matching. This head handles what the short-video teacher cannot: minute-scale narrative structure, causal dependencies that span tens of seconds, and global temporal coherence. Because this head sees ground-truth long videos, it learns to produce velocity estimates that respect long-range dependencies — but at the cost of averaging away the sharp local detail that the short-video teacher has already mastered.

  3. A mode-seeking Distribution Matching head that aligns every sliding-window segment of the student's output to a frozen short-video teacher via a reverse-KL gradient (implemented through DMD/VSD-style score difference terms). This head handles what the scarce long-video data cannot: high-fidelity local textures, sharp motion dynamics, and the realism that comes from a teacher trained on web-scale short-video data. Critically, this head is trained on-policy — it operates on the student's own rollouts — so it learns to correct the specific failure modes that the student exhibits, not just generic distribution matching.

The decoupling is structural, not just conceptual. By routing the two signals through separate lightweight decoder heads that share a unified backbone, the architecture resolves the gradient interference that would occur if both objectives were forced through a single velocity predictor. This is validated empirically in the ablation study (Table 2), where "removing the DDT dual heads and naively training a single velocity predictor with both mean-seeking SFT and mode-seeking teacher alignment leads to the largest drop across all metrics."

The paper positions itself as orthogonal to causal autoregressive methods rather than competing with them. Section 5 and Appendix E explicitly note that the decoupled bidirectional model could serve as a base for causal AR training, or could be distilled into a causal sampler. This is important because it frames the contribution not as a replacement for existing long-video paradigms but as a complementary training strategy that addresses the specific fidelity-coherence tradeoff that all current methods face.

A crucial practical motivation that the paper emphasizes: because the Distribution Matching head is trained via DMD/VSD-style distillation, it serves as a few-step sampler at inference time, enabling fast long-video synthesis. This is not an incidental benefit — it's part of the design. The paper notes that they "no longer need multi-stage training and distillation; the output model with DM head is directly capable of few-step inference, unlocking fast minute-scale video generation." This addresses a practical deployment concern: long videos require many denoising steps in standard diffusion, and reducing the number of function evaluations makes minute-scale generation computationally feasible at interactive speeds.

Relationship to Prior Decoupled Architectures

The paper builds directly on the Decoupled Diffusion Transformer (DDT) introduced by Wang et al. (2025c). DDT proposed separating velocity prediction into multiple heads for different purposes, but the prior work did not apply this to the specific tension between mean-seeking supervised training and mode-seeking distribution matching in the long-video setting. The paper's adaptation is to repurpose the decoupled architecture specifically for resolving the gradient interference between flow matching and reverse-KL teacher alignment, with each head specialized to one objective.

The distribution matching component inherits from the DMD (Yin et al., 2024b), DMD2 (Yin et al., 2024a), and VSD (Wang et al., 2023b) literature, which established that the gradient of a reverse-KL divergence between student and teacher distributions in diffusion/flow models can be expressed as the difference between teacher and student score/velocity estimates on noisy states. The paper adapts this general framework to the sliding-window setting: instead of matching full sequences, they match every LL-frame segment of the student's output to the teacher distribution, where LL corresponds to the teacher's native temporal horizon (~5 seconds). This allows the teacher — which was trained only on short clips — to provide meaningful distribution matching signals on its native timescale, while the global long-context encoder handles the coordination across windows.

The sliding-window mechanism also connects to recent work like LongLive (Yang et al., 2026), which used a similar windowing approach for autoregressive models. The authors explicitly acknowledge building on LongLive's solution for the image-latent/video-latent mismatch at window boundaries (Appendix C), adapting it from causal AR models to their non-causal bidirectional architecture.

3. Technical Approach

3.1 Reader Orientation

The system is a training framework for a video diffusion model that generates minute-scale videos by learning from two complementary sources: scarce real long videos (which teach global narrative structure) and a frozen short-video teacher (which teaches local visual realism on 5-second windows). It solves the problem that naively training on both signals produces gradient interference — the long-video objective wants to average over uncertain futures while the teacher matching objective wants to commit to sharp high-fidelity modes — by routing these two objectives through separate decoder heads that share a single long-context encoder, structurally decoupling the conflicting signals while allowing the shared backbone to learn representations useful for both.

3.2 Big-Picture Architecture (Diagram in Words)

The system has five major components:

  1. Shared Long-Context Encoder ($E_\phi$) — a video diffusion transformer with full-range temporal attention that takes a noisy long-video latent, timestep, and conditioning as input and produces a spatiotemporal feature tensor $h_t$. This is the single backbone through which all information flows.

  2. Flow Matching Head ($D_\theta^{\text{FM}}$) — a lightweight transformer decoder that reads from $h_t$ and predicts a global velocity field $u_\theta$ for the full long video. Trained via supervised flow matching (mean-seeking $L_2$ loss) on real long-video data only.

  3. Distribution Matching Head ($D_\psi^{\text{DM}}$) — a second lightweight transformer decoder that also reads from the same $h_t$ and predicts a velocity field $v_\psi$ for the full long video. Trained via mode-seeking reverse-KL gradients (DMD/VSD-style) by comparing windowed segments of the student's output to a frozen short-video teacher. This head serves as the few-step sampler at inference time.

  4. Frozen Short-Video Teacher ($u_{\text{teacher}}$) — a pretrained 5-second video diffusion model (e.g., Wan 1.3B or 14B) whose velocity predictions are queried on windowed segments but which is never updated. Provides the local realism prior.

  5. Fake Score Estimator ($v_{\text{fake}}$) — a small model trained on-the-fly with score matching on the student's own window predictions, used to estimate the student's score for the DMD/VSD gradient computation.

Information flows as follows: A noisy long-video latent $x_t^{\text{long}}$ with conditioning $c$ and timestep $t$ enters the shared encoder $E_\phi$ → the encoder produces representation $h_t$ → the FM head $D_\theta^{\text{FM}}$ reads $h_t$ and predicts a global velocity $u_\theta$, which is compared against ground-truth velocities from real long videos to compute $\mathcal{L}_{\text{SFT}}$ → simultaneously, the DM head $D_\psi^{\text{DM}}$ reads $h_t$ and predicts $v_\psi^{\text{long}}$, from which sliding windows are cropped → each window's velocity is compared against the teacher's velocity on that window, with the difference scaled and backpropagated as a mode-seeking gradient → the fake score estimator $v_{\text{fake}}$ provides the student-side score estimate needed for the DMD/VSD gradient → both losses update the shared encoder, while each head is updated only by its respective signal.

At inference time, the FM head is discarded entirely; the DM head generates the video via few-step sampling, leveraging representations from the shared encoder that have been shaped by both long-video supervision and local teacher alignment.

3.3 Roadmap for the Deep Dive

  • First, the mathematical preliminaries (rectified flow, the noising path, and the standard flow-matching objective), since both the SFT anchor and the teacher matching loss build on this framework and the tension between mean-seeking and mode-seeking cannot be understood without it.
  • Second, the sliding-window view of long videos, which formalizes the key insight that a long-video generator induces marginal distributions over local windows and that these marginals can be individually matched to a short-video teacher — this is the conceptual bridge that makes decoupling possible.
  • Third, the decoupled architecture (the shared encoder and two separate heads), explaining why gradient interference necessitates structural separation, how the DDT design from Wang et al. (2025c) is adapted, and what each head is responsible for.
  • Fourth, the local reverse-KL via DMD/VSD, walking through how an intractable DKL(q∥p)D_{\text{KL}}(q \| p) is converted into a computable gradient surrogate using velocity differences on noised states, why the reverse KL is mode-seeking, and the sliding-window cropping mechanics including the image-latent/video-latent boundary issue.
  • Fifth, the SFT anchor on long videos (the standard flow-matching loss applied to full-length real long clips), explaining why this is necessary even though it produces blurry outputs on its own and how it complements rather than competes with the teacher matching signal.
  • Sixth, the joint objective and training procedure, showing how the two losses are combined with a scalar weight, which parameters receive which gradients, and the two-minibatch training step structure.

3.4 Detailed, Sentence-Based Technical Breakdown

This is a training methodology paper whose core idea is that long-video generation fidelity can be recovered by decoupling the mean-seeking supervision on global structure from the mode-seeking teacher alignment on local windows, implemented through a Decoupled Diffusion Transformer with separate velocity heads that share a unified encoder.

Rectified Flow Preliminaries

The paper operates in the latent space of a video variational autoencoder (VAE) and uses the rectified flow parameterization (Lipman et al., 2023; Liu et al., 2023), which is the standard for recent large-scale video models like Wan. Understanding this parameterization is essential because the central tension in the paper — between mean-seeking and mode-seeking objectives — is expressed in terms of velocity fields and their approximations.

Noisy state construction. Given a clean video latent $x_0 \in \mathbb{R}^{T \times H \times W \times C}$ and a prior noise sample $z \sim \mathcal{N}(0, I)$, the deterministic noising path is defined as:

xt=It(x0,z)≜(1−t) x0+t z,t∈[0,1]x_t = I_t(x_0, z) \triangleq (1 - t)\, x_0 + t\, z, \quad t \in [0, 1]

where $x_t$ is the noised state at time $t$, $x_0$ is the clean video latent, and $z$ is the pure Gaussian noise.

What it computes: this is a straight-line interpolation between the clean data point at $t = 0$ and pure noise at $t = 1$. At $t = 0.3$, the state is a 70%-30% blend of the clean video and noise; at $t = 0.7$, it is 30%-70%. The noise is added deterministically given $x_0$ and $z$ — there is no stochasticity in the path itself (unlike standard diffusion which uses random noise injection at each step).

Why this form: the linear interpolation simplifies both training and sampling. The target velocity (shown below) becomes constant — simply $x_0 - z$ — rather than depending on the noise schedule. This means the model only needs to learn to predict a single direction vector per $(x_t, t)$ pair rather than adapting to a time-varying noise level. It also means the generative ODE has straight trajectories, which enables faster sampling with fewer integration steps compared to curved diffusion paths.

Velocity field and ODE. The noising path induces a marginal velocity field $u: \mathbb{R}^d \times [0, 1] \to \mathbb{R}^d$ (where $d$ is the latent dimensionality) that describes how probability mass flows over time. The corresponding generative ordinary differential equation is:

dxtdt=−u(xt,t),x1∼π\frac{dx_t}{dt} = -u(x_t, t), \quad x_1 \sim \pi

What it computes: given a noise sample $x_1$ drawn from the prior $\pi = \mathcal{N}(0, I)$, this ODE can be solved backward from $t = 1$ to $t = 0$ to produce a sample from the data distribution. The velocity field $u(x_t, t)$ tells us which direction to move the state at time $t$ to follow the probability flow toward the data. The negative sign indicates we are moving backward in time — from noise toward data.

Why this form: the ODE perspective unifies training and sampling. If we can learn an approximation $u_\theta$ of the true velocity field $u$, then sampling reduces to solving this ODE with a numerical integrator. There is no separate "sampling algorithm" — it is just ODE integration. This contrasts with standard diffusion, where sampling requires a specific ancestral sampling procedure tied to the noise schedule.

Standard flow-matching objective. The network $u_\theta$ is trained to approximate the marginal velocity field via:

LFM(θ)=Ex0,z,t ∥uθ(xt,t,c)−u(xt,t∣x0,z)∥22\mathcal{L}_{\text{FM}}(\theta) = \mathbb{E}_{x_0, z, t} \, \big\| u_\theta(x_t, t, c) - u(x_t, t \mid x_0, z) \big\|_2^2

where $u(x_t, t \mid x_0, z) = x_0 - z$ is the conditional velocity (the constant direction from the noised state to the clean data), $c$ denotes conditioning (e.g., a text prompt), and $\mathbb{E}_{x_0, z, t}$ denotes expectation over clean videos, noise samples, and uniformly sampled timesteps.

What it computes: for each training sample, we randomly pick a clean video $x_0$, a noise sample $z$, and a timestep $t$, construct $x_t$ via the linear interpolation, ask the model to predict the velocity at $(x_t, t, c)$, and compare against the ground-truth direction $x_0 - z$ — the vector pointing from the noised state to the clean data. The $L_2$ loss penalizes deviations in both magnitude and direction.

Why this form: mean squared error on the velocity is equivalent to score matching up to a time-dependent scaling, making it a principled objective for learning the marginal velocity field. Critically, this objective is mean-seeking: the optimal predictor under $L_2$ loss is the conditional expectation of the target, $\mathbb{E}[x_0 - z \mid x_t, t, c]$. When multiple clean videos $x_0$ could give rise to the same noisy observation $x_t$, the model learns to predict the average of those possibilities — the conditional mean. This is the mathematical root of the blurriness problem: when long-video data is scarce, the averaging effect washes out the sharp modes that the short-video teacher has already learned.

The expert teacher assumption. The paper assumes the existence of a pretrained short-video teacher — a DiT-style (Peebles & Xie, 2023) flow model $u_{\text{teacher}}$ whose velocity field $u_{\text{teacher}}(x_t, t, c)$ can be queried at arbitrary $(x_t, t, c)$ tuples. The teacher was trained on web-scale 5-second clips and has internalized a sharp prior over realistic short-timescale dynamics. Crucially, the teacher's original short-clip training data and post-training strategies (e.g., RLHF, reward model fine-tuning) need not be accessible — the teacher is treated as a black-box velocity oracle. This is practically important because short-video models from major labs come with extensive proprietary post-training that would be impossible to replicate; the method only needs query access to the final model.

The Sliding-Window View of Long Videos

The paper's central conceptual move is to view a long video not as a monolithic entity but as a collection of overlapping local segments, each of which should individually look like a high-quality short clip. This perspective allows a short-video teacher — which has no understanding of long-range structure — to provide meaningful supervision on its native timescale.

Window definition. Given a long video latent $x_0^{\text{long}}$ spanning $T_{\text{long}}$ frames and a window length $L$ corresponding to approximately 5 seconds (the teacher's native horizon), the operation:

cropk(x0long)∈RL×H×W×C\text{crop}_k(x_0^{\text{long}}) \in \mathbb{R}^{L \times H \times W \times C}

extracts the contiguous $L$-frame segment starting at frame index $k$, where $k$ ranges over $\{0, 1, \dots, \lceil T_{\text{long}}/L \rceil - 1\}$. The windows can be densely overlapping (e.g., stride 1) or sparsely sampled depending on computational constraints.

What it computes: for a 30-second video at 16 frames per second (480 frames total) and a 5-second window (80 frames), this operation produces up to 401 overlapping windows (frames 0–79, 1–80, 2–81, etc.). Each window captures a local temporal neighborhood that the short-video teacher is equipped to evaluate.

Why this form: by decomposing the long video into teacher-native-length segments, we can query the teacher on inputs that match its training distribution. The teacher was never trained on 480-frame sequences and would produce meaningless velocity estimates if given one; but it can produce reliable estimates on any 80-frame segment. The sliding nature ensures that every temporal position in the long video is covered by some window, providing dense supervision over the full sequence.

Marginal distributions and the alignment objective. Let $q_\Phi^{(k)}$ denote the marginal distribution over the $k$-th sliding window induced by the long-video student model with parameters $\Phi$, and let $p_{\text{teacher}}$ denote the short-video teacher distribution. The window-wise alignment objective is:

Lseg(Φ)=Ek[DKL(qΦ(k) ∥ pteacher)]\mathcal{L}_{\text{seg}}(\Phi) = \mathbb{E}_k \big[ D_{\mathrm{KL}}\big(q_\Phi^{(k)} \,\|\, p_{\text{teacher}}\big) \big]

where $D_{\mathrm{KL}}(q \| p)$ is the Kullback-Leibler divergence (reverse direction), $\Phi \triangleq (\phi, \psi)$ collects the shared encoder and DM head parameters, and $\mathbb{E}_k$ averages over all window positions.

What it computes: for each window position $k$, we measure the divergence between the distribution of student-generated windows and the teacher's distribution. This asks: "does the $k$-th 5-second segment of the student's long video look like it came from the short-video teacher's distribution?" The expectation over $k$ enforces this constraint at every temporal position, so the full long video must be locally realistic everywhere, not just on average.

Why this form — the reverse KL choice: the KL divergence is asymmetric. The forward KL, $D_{\text{KL}}(p_{\text{teacher}} \| q_\Phi^{(k)})$, is mean-seeking: it penalizes the student for not covering all modes of the teacher, encouraging the student to spread its mass broadly to avoid missing any teacher-supported region. This would be disastrous — it would push the student toward the same averaging behavior that causes blurriness. The reverse KL, $D_{\text{KL}}(q_\Phi^{(k)} \| p_{\text{teacher}})$, is mode-seeking: it penalizes the student heavily for generating samples in regions where the teacher has low density, but does not penalize the student for ignoring some teacher modes. This encourages the student to concentrate its mass on the teacher's sharp, high-fidelity modes — exactly the behavior needed to recover local realism. The student can pick a crisp realization from the teacher's distribution without being forced to average over all possible realizations.

Why matching window marginals rather than the full joint distribution: the teacher has no ability to evaluate joint distributions over minute-scale sequences. But by enforcing that every local window individually matches the teacher, we ensure that local dynamics are realistic everywhere. The global structure across windows is handled separately by the SFT loss on the FM head. This separation of concerns is the core architectural insight: local realism is a per-window property that can be supervised by a short-video expert, while global coherence requires long-video data.

The Decoupled Diffusion Transformer Architecture

The naive approach — training a single velocity predictor with both the mean-seeking SFT loss and the mode-seeking teacher alignment loss — creates gradient interference. The SFT objective pulls toward the conditional mean (averaging over possibilities), while the reverse-KL teacher alignment pushes toward high-density modes (committing to specific realizations). Forcing both signals through one output head means the model must find a compromise velocity that satisfies neither objective well, resulting in degraded performance on both local quality and global coherence (empirically validated in the ablation study, Table 2, where removing dual heads produces the largest drop across all metrics).

The paper resolves this by instantiating the long-video student as a Decoupled Diffusion Transformer, adapted from Wang et al. (2025c), where a shared feature encoder is followed by separate decoder heads for each objective.

Condition encoder. The shared backbone is:

ht=Eϕ(xtlong,t,c)h_t = E_\phi(x_t^{\text{long}}, t, c)

where $x_t^{\text{long}}$ is the full noisy long-video latent, $t$ is the diffusion timestep, $c$ is the conditioning (text prompt, and potentially other modalities), and $h_t$ is the output spatiotemporal feature tensor.

What it computes: the encoder processes the entire long-video latent with full-range temporal attention, meaning every frame can attend to every other frame. This builds representations that capture dependencies spanning the full video length. The timestep and conditioning are injected through standard mechanisms (adaptive layer norm or cross-attention, following the base DiT architecture).

Why this form: full-range attention is essential for long-range coherence. If the encoder used localized or windowed attention, it could not learn dependencies between frames 0 and 400 — exactly the kind of long-range structure that the short-video teacher cannot provide. The encoder must have a global receptive field to serve as the shared representation for both heads. The computational cost of full attention on long sequences is addressed through sequence parallelism (DeepSpeed Ulysses, Jacobs et al., 2023, as noted in Appendix A), which shards the sequence dimension across GPUs.

Two velocity heads. On top of $h_t$, two lightweight transformer decoders produce velocity predictions:

uθ(xtlong,t,c)=DθFM(ht,t,c)u_\theta(x_t^{\text{long}}, t, c) = D_\theta^{\text{FM}}(h_t, t, c)

vψ(xtlong,t,c)=DψDM(ht,t,c)v_\psi(x_t^{\text{long}}, t, c) = D_\psi^{\text{DM}}(h_t, t, c)

where $D_\theta^{\text{FM}}$ is the Flow Matching head producing velocity $u_\theta$, and $D_\psi^{\text{DM}}$ is the Distribution Matching head producing velocity $v_\psi$.

What they compute: both heads take the same encoder representation $h_t$ and predict a velocity field over the full long video. They are architecturally identical (lightweight transformer decoders) but receive different gradient signals and thus learn different functions. The FM head learns the conditional mean velocity from real long videos; the DM head learns to produce velocities that, when integrated, yield local windows in the teacher's high-fidelity modes.

Why two heads instead of two separate models: sharing the encoder forces both objectives to shape a common representation. The encoder must learn features that simultaneously support accurate long-range velocity prediction (for the FM head) and local realism matching (for the DM head). This shared representation is what allows the DM head — which is never directly trained on long videos — to produce globally coherent videos at inference time. The encoder has internalized the long-range structure from the SFT loss, and the DM head can leverage that structure while specializing in local fidelity. If the two heads had separate encoders, the DM head's encoder would lack any long-range training signal and would produce locally sharp but globally incoherent outputs.

Why decoupled gradients: by routing gradients from $\mathcal{L}_{\text{SFT}}$ only through the FM head and $E_\phi$, and gradients from $\mathcal{L}_{\text{seg}}$ only through the DM head and $E_\phi$, each head specializes without interference. The FM head never sees the mode-seeking signal, so it never tries to commit to specific modes — it remains a well-calibrated mean predictor. The DM head never sees the mean-seeking $L_2$ loss, so it is never pulled toward averaging — it learns pure mode-seeking behavior. The encoder sees both signals and learns to produce representations that serve both needs.

Architectural weight. The decoders are "lightweight" relative to the encoder. While exact layer counts are not specified, the design philosophy follows DDT: the encoder does the heavy lifting of temporal reasoning, while the heads are shallow networks that specialize the representation for their specific prediction task. This keeps the total parameter count manageable while giving each objective dedicated capacity.

Local Reverse-KL via DMD/VSD

The distribution matching objective $\mathcal{L}_{\text{seg}}$ in Equation (5) is conceptually clean but computationally intractable: we cannot directly evaluate or differentiate through a KL divergence between implicitly defined distributions over video windows. The paper adopts the technique from Distribution Matching Distillation (Yin et al., 2024b, 2024a) and Variational Score Distillation (Wang et al., 2023b), which provides an expression for the gradient of a reverse KL between a student and teacher in diffusion/flow models using score or velocity differences on noised states.

The gradient surrogate. For flow models with the linear noising path $x_t = (1-t)x_0 + t\epsilon$ (where $\epsilon \sim \mathcal{N}(0, I)$ is equivalent to the prior $z$), the DMD result states that the gradient of the reverse KL $D_{\text{KL}}(q_\Phi^{(k)} \| p_{\text{teacher}})$ with respect to the student parameters can be expressed as an expectation involving the difference between the teacher's and student's scores on noised versions of student-generated samples. Adapted to the velocity parameterization, the window-level gradient surrogate is:

∇^ Lseg=Et,k[λ(t) (vfake(x^tlong,t,c)−uteacher(x^t(k),t,c)) ⁣⊤∇ x^0(k)]\widehat{\nabla}\, \mathcal{L}_{\text{seg}} = \mathbb{E}_{t,k} \Big[ \lambda(t) \, \big( v_{\text{fake}}(\hat{x}_t^{\text{long}}, t, c) - u_{\text{teacher}}(\hat{x}_t^{(k)}, t, c) \big)^{\!\top} \nabla\, \hat{x}_0^{(k)} \Big]

where $\hat{x}_0^{(k)} = \text{crop}_k(\hat{x}_0^{\text{long}})$ is a generated student window, $\hat{x}_t^{(k)} = (1-t)\hat{x}_0^{(k)} + t\epsilon$ is its noised version, $v_{\text{fake}}$ is a fake score estimator trained on the student's own window predictions, $u_{\text{teacher}}(\hat{x}_t^{(k)}, t, c)$ is the teacher's velocity prediction on the noised window, $\lambda(t)$ is a time-dependent weighting that absorbs the DMD/VSD score-to-velocity conversion factors, and $\mathbb{E}_{t,k}$ denotes expectation over randomly sampled timesteps and window positions.

What it computes: the gradient pushes the student's generated window $\hat{x}_0^{(k)}$ in a direction that reduces the velocity difference between the student (as estimated by $v_{\text{fake}}$) and the teacher on the noised version of that window. Specifically, the vector $(v_{\text{fake}} - u_{\text{teacher}})$ tells us how the student's implied velocity field differs from the teacher's at the noised state $\hat{x}_t^{(k)}$. Multiplying by the Jacobian of the window with respect to the student parameters (via backpropagation through $\hat{x}_0^{(k)}$) tells us how to update the student so that its velocity field moves closer to the teacher's. The $v_{\text{fake}}$ term is treated as a stop-gradient (not backpropagated through), so the effective update direction is $-u_{\text{teacher}}^\top \nabla \hat{x}_0^{(k)}$ (pushing toward the teacher's implied direction) minus $-v_{\text{fake}}^\top \nabla \hat{x}_0^{(k)}$ (a correction for the student's own current behavior). This correction term is crucial: without it, the gradient would push the student toward the teacher's distribution regardless of where the student currently is, which can lead to mode collapse. With the correction, the gradient is zero when the student's distribution already matches the teacher's, making it a proper gradient of the KL divergence.

Why this form: the DMD/VSD derivation shows that the reverse-KL gradient can be decomposed into a difference of score functions on noised states, which is computable because we can add noise to the student's generated samples and query both the student's and teacher's velocity predictions on the resulting noisy states. The alternative — directly differentiating an estimator of the KL divergence — would require density estimates that are unavailable for implicit generative models like diffusion transformers.

The fake score estimator $v_{\text{fake}}$. The student's own score/velocity on its generated windows is not trivially available because the student is a generator, not a density estimator. The paper trains a separate fake score estimator $v_{\text{fake}}$ using score matching on the student's window predictions $\hat{x}_0^{(k)}$. Specifically, after each student update step, the fake score estimator is trained for 5 steps on the current batch of student-generated windows. This is an on-policy estimator — it tracks the student's evolving distribution rather than being trained once on a static dataset.

Why on-policy estimation: if $v_{\text{fake}}$ were trained once on the initial student distribution and then frozen, it would become increasingly inaccurate as the student's distribution shifts during training. The resulting gradient $v_{\text{fake}} - u_{\text{teacher}}$ would no longer represent the true velocity difference at the student's current samples, and the update would be misdirected. The 5-step retraining per batch keeps the estimator approximately synchronized with the student while being computationally manageable.

Why 5 steps: this is an empirical tradeoff. More steps would give a more accurate fake score estimate but increase the per-iteration cost. Five steps provides enough accuracy for the gradient direction to be useful without dominating the training time. This follows the practice established in the DMD literature.

Stop-gradient on the velocity difference. The term $(v_{\text{fake}} - u_{\text{teacher}})$ is treated as a constant when backpropagating the gradient — gradients flow only through $\hat{x}_0^{(k)}$ (the generated window) and not through the velocity predictions themselves. This means the update changes the student's parameters to modify $\hat{x}_0^{(k)}$ such that the velocity difference decreases, rather than modifying the velocity predictions directly. This is the standard DMD gradient formulation and ensures that the student is trained as a generator, not as a velocity estimator.

Cropping the mode-seeking head for window alignment. The DM head produces a velocity field $v_\psi^{\text{long}}(x_t^{\text{long}}, t, c)$ over the full long video. To compute the teacher matching loss on a specific window, the paper crops both the generated velocity and the noised latent:

xtlong=(1−t) x0long+t ϵx_t^{\text{long}} = (1-t)\, x_0^{\text{long}} + t\, \epsilon

ht=Eϕ(xtlong,t,c)h_t = E_\phi(x_t^{\text{long}}, t, c)

vψlong(xtlong,t,c)=DψDM(ht,t,c)v_\psi^{\text{long}}(x_t^{\text{long}}, t, c) = D_\psi^{\text{DM}}(h_t, t, c)

vψ(k)(xtlong,t,c)=cropk ⁣(vψlong(xtlong,t,c))v^{(k)}_\psi(x_t^{\text{long}}, t, c) = \text{crop}_k\!\Big(v_\psi^{\text{long}}(x_t^{\text{long}}, t, c)\Big)

where $x_0^{\text{long}}$ is a clean long video generated by the student (via sampling with the DM head), $\epsilon \sim \mathcal{N}(0, I)$ is fresh noise, and $\hat{x}_t^{(k)} = \text{crop}_k(\hat{x}_t^{\text{long}})$ is the noised window.

What it computes: the student first generates a full long video $x_0^{\text{long}}$ (during training, this is done on-policy — the current student generates a sample, which is then used for training). Noise is added to create $x_t^{\text{long}}$, which is fed through the shared encoder to produce $h_t$. The DM head predicts the velocity for the full sequence, and then the specific window $k$ is extracted via cropping. This cropped velocity is compared against the teacher's prediction on the same window. Gradient flows back through the crop operation, through the DM head, and through the shared encoder to update parameters.

Why generate, then noise, then predict: the student must be trained on its own outputs (on-policy) so that the distribution matching gradient addresses the specific discrepancies between the student's current distribution and the teacher's. If we used ground-truth long videos as the starting point, the gradient would tell us how to make the teacher-matchable windows look more like themselves — a degenerate signal. The noising step is necessary because the teacher's velocity predictions are defined on noisy states (the teacher is a denoising model, not a discriminator on clean data). The linear noising path provides a bridge between the student's clean generation and the domain where the teacher can provide meaningful feedback.

The image-latent/video-latent boundary issue. A subtle but practically critical implementation detail (Appendix C): modern video VAEs produce latent sequences where the first latent of a clip is special — it is an "image latent" that encodes the first frame as a still image, while subsequent latents are "video frame latents" that encode temporal differences. When cropping a window from the middle of a long sequence (at offset $p > 0$), the window's first latent would be a video frame latent, but the teacher expects an image latent. This semantic mismatch at window boundaries causes the teacher to produce corrupted velocity estimates.

The solution, adapted from LongLive (Yang et al., 2026): for any window starting at offset $p > 0$, decode the latent prefix $[0, \dots, p-1]$ with the frozen VAE, take the last decoded RGB frame, and re-encode it into a fresh image latent. Prepend this reconstructed image latent to the student's windowed video latents before computing the DMD loss. The reconstructed latent is masked out during loss computation to avoid backpropagating through the VAE decoder-encoder round-trip. This provides the teacher with a semantically correct image latent at the window start without introducing VAE gradients that could destabilize training. The authors note this strategy is effective for both causal AR models (as in LongLive) and their non-causal bidirectional architecture.

SFT Flow-Matching Anchor on Long Videos

The teacher matching loss alone cannot teach global, minute-scale coherence — the short-video teacher has no concept of what should happen 30 seconds into a video. To learn long-range dynamics, the FM head is trained with a standard supervised flow-matching objective on real long-video data.

Objective. Let $x_0^{\text{long}} \sim p_{\text{long}}$ be a real long video latent from the curated training set, and let $x_t^{\text{long}}$ be constructed via the same linear noising path using a global prior $z^{\text{long}} \sim \mathcal{N}(0, I)$:

LSFT(ϕ,θ)=Ex0long,zlong,t[∥uθ(xtlong,t,c)−(x0long−zlong)∥22]\mathcal{L}_{\text{SFT}}(\phi, \theta) = \mathbb{E}_{x_0^{\text{long}}, z^{\text{long}}, t} \Big[ \big\| u_\theta(x_t^{\text{long}}, t, c) - (x_0^{\text{long}} - z^{\text{long}}) \big\|_2^2 \Big]

where $u_\theta(x_t^{\text{long}}, t, c)$ is the FM head's velocity prediction (which depends on $h_t = E_\phi(x_t^{\text{long}}, t, c)$), and $(x_0^{\text{long}} - z^{\text{long}})$ is the constant ground-truth velocity from the noised state to the clean video.

What it computes: identical to the standard flow-matching loss in Equation (3), but applied exclusively to full-length long videos and routed through the FM head. The loss measures the $L_2$ distance between the FM head's predicted velocity field and the true direction toward the clean data, encouraging the model to learn velocity estimates that, when integrated backward, reconstruct real long video trajectories.

Why this anchors global structure: because the loss is computed on the full sequence, the model must learn velocity predictions that respect temporal dependencies spanning the entire video length. A velocity prediction at frame 300 must be consistent with the content at frame 50 in a way that reflects real causal relationships — the only way to achieve low loss is to internalize the long-range patterns present in the training data. This is the "mean-seeking" aspect: when multiple valid continuations are possible, the model learns to predict the average, which may lose sharpness but captures the broad structural regularities.

Why route through only the FM head: the FM head specializes in this mean-seeking prediction. The shared encoder $E_\phi$ receives gradients from this loss, so it learns to produce representations that support long-range velocity estimation. The DM head does not receive gradients from $\mathcal{L}_{\text{SFT}}$, preserving its specialization in mode-seeking local realism without being pulled toward averaging behavior.

Training data. The paper uses a curated dataset of more than 100,000 videos ranging from 10 seconds to minutes, with an average length of 31 seconds (Appendix B). Sources include the Sekai dataset (Li et al., 2025c), a subset of MiraData (Ju et al., 2024), and filtered single-shot videos from the internet. Videos exceeding 61 seconds are subsampled to fit within the temporal upper bound. This is a non-trivial curation effort: single-shot videos are specifically selected because they provide continuous temporal structure rather than edited cuts, which would introduce artificial scene boundaries that disrupt long-range learning.

The $L_2$ blurriness problem revisited. The SFT loss alone produces models that, at convergence, generate blurry outputs (as shown experimentally in Figure 4, where LongSFT and MixSFT baselines exhibit softened textures and washed-out details). This is a direct consequence of the $L_2$ objective's mean-seeking property applied to a data-scarce regime. When the model encounters an ambiguous state — a partially denoised video that could resolve into several different plausible futures — $L_2$ optimization drives it toward the average of those futures, which is typically a blurry superposition. The short-video teacher, trained on abundant data, has sharp modes; the long-video SFT, trained on scarce data, has diffuse averages. The DM head's mode-seeking signal is specifically designed to correct this.

Joint Objective and Training Procedure

The full training combines the two complementary signals with a scalar weight $\lambda_{\text{seg}}$ controlling the relative strength of the teacher matching loss:

Ltotal(ϕ,θ,ψ)=LSFT(ϕ,θ)+λseg Lseg(ϕ,ψ)\mathcal{L}_{\text{total}}(\phi, \theta, \psi) = \mathcal{L}_{\text{SFT}}(\phi, \theta) + \lambda_{\text{seg}} \, \mathcal{L}_{\text{seg}}(\phi, \psi)

where $\mathcal{L}_{\text{SFT}}$ is the supervised FM loss on real long videos (Equation 14), $\mathcal{L}_{\text{seg}}$ is the conceptual window-level reverse KL (Equation 5, implemented via the DMD/VSD gradient surrogate in Equation 9), and $\lambda_{\text{seg}}$ balances the two terms.

What it computes: a single scalar loss value that is minimized during training. However, note that $\mathcal{L}_{\text{seg}}$ is not evaluated directly — only its gradient surrogate is injected. This means we cannot report a numeric value for this term during training; we can only measure its effect through the parameter updates it induces.

Why the $\lambda_{\text{seg}}$ hyperparameter: the two losses operate at different scales and have different noise characteristics. $\mathcal{L}_{\text{SFT}}$ is computed from clean ground-truth data and has low variance. The DMD/VSD gradient is computed from on-policy student samples and involves a fake score estimator trained for only 5 steps, making it substantially noisier. The weight $\lambda_{\text{seg}}$ must be tuned to prevent the noisier teacher matching signal from overwhelming the SFT anchor or, conversely, being drowned out entirely. The paper does not report the specific value used, but it is implicitly a tuned hyperparameter.

Gradient flow — which parameters receive which signals. The key design choice is the gradient routing:

∇ϕLtotal=∇ϕLSFT+λseg ∇^ϕLseg\nabla_\phi \mathcal{L}_{\text{total}} = \nabla_\phi \mathcal{L}_{\text{SFT}} + \lambda_{\text{seg}} \, \widehat{\nabla}_\phi \mathcal{L}_{\text{seg}}

∇θLtotal=∇θLSFT\nabla_\theta \mathcal{L}_{\text{total}} = \nabla_\theta \mathcal{L}_{\text{SFT}}

∇ψLtotal=λseg ∇^ψLseg\nabla_\psi \mathcal{L}_{\text{total}} = \lambda_{\text{seg}} \, \widehat{\nabla}_\psi \mathcal{L}_{\text{seg}}

where $\phi$ are the shared encoder parameters, $\theta$ are the FM head parameters, and $\psi$ are the DM head parameters.

What this computes: the shared encoder $E_\phi$ receives gradients from both objectives, allowing it to learn representations that serve both global coherence and local fidelity. The FM head $D_\theta^{\text{FM}}$ receives gradients only from the SFT loss — it never sees the mode-seeking signal and remains a pure mean predictor. The DM head $D_\psi^{\text{DM}}$ receives gradients only from the teacher matching loss — it never sees the $L_2$ regression target and remains a pure mode-seeking generator.

Why this decoupled gradient flow is essential: if the FM head received teacher matching gradients, it would begin to over-commit to specific modes, damaging its ability to provide well-calibrated mean predictions for the SFT anchor. If the DM head received SFT gradients, it would be pulled toward averaging, defeating its purpose as a mode-seeking generator. This complete separation of gradient signals is what resolves the interference that the ablation study (Table 2) shows causes the largest performance degradation when removed.

Training step structure — two minibatches per iteration. Each training iteration uses two separate minibatches:

  1. SFT minibatch: a batch of real long videos sampled from the curated training set. The FM head and shared encoder are updated using $\mathcal{L}_{\text{SFT}}$. This batch does not involve the teacher, the DM head, or any generation.

  2. Teacher matching minibatch: the student (using the DM head) generates on-policy long-video samples. Sliding windows are extracted from these samples, noised, and used to compute the DMD/VSD gradient surrogate. The fake score estimator $v_{\text{fake}}$ is trained for 5 steps on these windows. The DM head and shared encoder are updated using the gradient surrogate. The FM head and the fake score estimator are not updated by this signal beyond the 5-step score matching.

Why two separate minibatches: the SFT objective needs real long videos that the student did not generate, while the teacher matching objective needs on-policy student samples. These require different data pipelines. The SFT batch provides a stable anchor preventing the student from drifting into unrealistic global structures, while the teacher matching batch provides the mode-seeking signal that sharpens local dynamics.

Why on-policy generation for teacher matching: if the student were matched to the teacher using pre-generated or static samples, the matching gradient would correct discrepancies that may no longer exist after the student has been updated. On-policy sampling ensures that the gradient addresses the current discrepancy between the student's actual distribution and the teacher's distribution at every step. This is standard in DMD/VSD and is essential for convergence to a distribution that locally matches the teacher.

Sequence parallelism for long contexts. Training on minute-scale videos requires processing sequences with hundreds of frames, which would exceed the memory of a single GPU. Appendix A specifies that DeepSpeed Ulysses (Jacobs et al., 2023) sequence parallelism is used, with a group size of 4 for A100 GPUs and 2 for GB200 GPUs. This shards the sequence dimension across GPUs, with each GPU holding a contiguous chunk of frames, while attention is computed in a distributed fashion. The implementation is built on the FastGen repository (Nie et al., 2026).

Dynamic batching and variable-length training. Training videos are treated as variable-length sequences and pre-processed into length-based buckets for sampling. This reduces padding waste — instead of padding all sequences to the maximum length, sequences of similar lengths are batched together. This is noted as being used "across training, reducing padding waste and IDLE time" (Appendix A). The temporal upper bound is 61 seconds, with longer videos subsampled.

Inference-time behavior. At inference, the FM head $D_\theta^{\text{FM}}$ is discarded entirely. Long videos are generated by sampling with the DM head $v_\psi$:

  1. Sample initial noise $x_1^{\text{long}} \sim \mathcal{N}(0, I)$.
  2. Solve the ODE $\frac{dx_t}{dt} = -v_\psi(x_t^{\text{long}}, t, c)$ backward from $t = 1$ to $t = 0$ using a numerical integrator with a small number of steps (few-step sampling, enabled by the DMD distillation).
  3. Decode the resulting latent with the frozen VAE to obtain the video.

Why the DM head can serve as a few-step sampler: the DMD training procedure inherently distills the teacher's multi-step generation process into the student's single forward pass. The mode-seeking reverse KL encourages the student to match the teacher's distribution after integration, not to match the teacher's per-step velocities. This means the student's velocity field is optimized for direct few-step integration rather than for approximating the teacher's intermediate states — a crucial distinction from standard flow matching. The result is that the DM head can produce high-quality samples in 4–8 steps (the exact number is not specified but follows from the DMD literature) rather than the 50+ steps typically needed for the base model.

Why the shared encoder enables globally coherent DM head generation despite the DM head never seeing long videos: the encoder $E_\phi$ received gradients from the SFT loss, which was computed on full long videos. It has therefore learned to produce representations $h_t$ that encode long-range temporal dependencies. When the DM head reads $h_t$, it operates on representations that already contain global structure, even though the DM head was never trained to produce it. The DM head's job reduces to decoding these structured representations into locally realistic velocities — a significantly easier task than learning global structure from scratch.

Relationship to standard two-stage training pipelines. Many long-video systems use a two-stage approach: pretrain on short videos, then fine-tune on long videos. This work differs in that both objectives are trained simultaneously through the decoupled architecture. The shared encoder learns from both sources concurrently, allowing the representations to be jointly optimized rather than sequentially adapted. The authors argue this avoids catastrophic forgetting of short-video fidelity and eliminates the need for multi-stage training and distillation (Section 3.7).

4. Key Insights and Innovations

Innovation 1: Long Video Generation Is an Extrapolation Problem, Not an Interpolation Problem

The paper's most fundamental conceptual contribution is the diagnosis that scaling video generation from seconds to minutes is qualitatively different from scaling image generation from low to high resolution — and that the field's dominant training strategy implicitly assumes the wrong analogy. This is articulated in Figure 1 and the accompanying argument in Section 1.

What the field assumed before this paper. The dominant industrial practice, used in systems like HunyuanVideo (Kong et al., 2024), CogVideoX (Yang et al., 2024), SkyReels (Chen et al., 2025b), and Seedance (Seawead et al., 2025), trains a single model on a mixture of videos at varying lengths, hoping that the model will smoothly generalize across temporal horizons. This approach is directly inherited from multi-resolution image training, where a model trained on 256×256, 512×512, and 1024×1024 images learns to generate at any resolution because the underlying patch distribution remains essentially the same — higher resolutions are interpolations of lower ones. The field implicitly assumed the same logic held for video: a model trained on 5-second, 15-second, and 30-second clips would learn a unified temporal representation that smoothly extends across durations. The paper explicitly names this assumption and argues it is "fundamentally flawed."

What makes the diagnosis distinctive. The paper crystallizes the failure as a category error between interpolation and extrapolation. A 1024×1024 image is an interpolation of a 256×256 image — the same underlying local patch distribution, sampled at a finer grid. A one-minute video, however, is not an interpolation of a 5-second video. It is an extrapolation that introduces new events, causal chains, and narrative structure that simply do not exist in the short-clip distribution. As the authors put it: "A one-minute video... encodes substantially more information, in some sense, similar to panorama generation but requires significantly stronger context understanding ability." This is not a quantitative scaling challenge (more frames, more compute) but a qualitative one (new types of temporal structure that cannot be inferred from short clips alone).

Why this reframing matters beyond the current paper. This diagnostic move has implications for how the field thinks about scaling laws in video generation. If long videos were interpolations of short ones, then scaling compute and data volume — even with only short-clip data — would eventually produce long-video capability through smooth generalization. The extrapolation diagnosis implies that no amount of short-video data can substitute for genuinely long-form training examples, because the information needed to produce causal chains spanning minutes is simply absent from 5-second clips. This reframes long-video generation from a scale problem to a data-structure problem: the bottleneck is not just data quantity but data semantics. The practical consequence is that mixing video lengths — which is computationally convenient — cannot close the fidelity-horizon gap because the model is being asked to learn long-range structure from data that, for the vast majority of training examples, contains no such structure. This is a fundamental argument, not an incremental refinement: it challenges the architectural assumption underlying most industrial-scale video models.

Evidence anchoring. The experimental results in Section 4.2 and Figure 4 directly support this diagnosis. Mixed-length SFT (MixSFT), which represents the industrial "soup" approach, achieves decent long-range context but produces "blurry" outputs with washed-out fine textures — the model is averaging away high-frequency detail, consistent with being forced to reconcile incompatible distributions. The ablation in Table 2 further shows that removing the SFT anchor on real long videos ("w/o SFT") degrades global consistency while removing the teacher matching degrades local quality — neither signal alone suffices, validating the claim that short-video data and long-video data provide complementary, non-substitutable information.

Innovation 2: Mean-Seeking and Mode-Seeking Objectives Are in Gradient Conflict, Requiring Architectural Decoupling

This is the paper's central theoretical insight and the justification for its architectural choices. The claim is that supervised flow matching (a mean-seeking L_2 loss) and reverse-KL teacher alignment (a mode-seeking distribution matching loss) are not just different objectives — they produce gradient interference when routed through a single velocity predictor, and this interference explains why existing approaches either lose local fidelity (SFT-only) or lose global coherence (teacher-only). The solution is not a better loss function but a structural decoupling of the two signals.

What the field assumed before this paper. Prior work on long video generation typically employed a single velocity predictor trained with one primary objective, possibly with auxiliary losses added as regularizers. When teacher distillation was used (e.g., CausVid, Self-Forcing), it was applied either as a separate training stage or as a weighted loss term on the same output head. The implicit assumption was that objectives can be combined through scalar weighting — that a single model can learn to satisfy multiple loss functions through a shared output. This is standard practice across deep learning and generally works when losses are aligned or at least not actively antagonistic.

What makes the diagnosis distinctive. The paper argues that mean-seeking and mode-seeking are not merely different but actively conflicting. The flow-matching L_2 loss optimizes toward the conditional expectation: when multiple futures are consistent with the current noisy state, the optimal prediction is the average of those futures, which produces a physically plausible but blurred result. The reverse-KL objective D_KL(q || p) is mode-seeking: it penalizes the student for placing mass where the teacher has low density, encouraging concentration on sharp modes. When both signals target the same velocity predictor, the model faces an impossible compromise. The SFT loss says "under uncertainty, average over all plausible futures." The teacher alignment says "commit to one sharp, high-fidelity realization." A single output cannot simultaneously average and commit to a mode.

The paper's key move is recognizing that this conflict is not just a matter of tuning \lambda_{\text{seg}} weight — it is structural. No scalar weighting can resolve it because the optimal velocity under one objective is fundamentally different from the optimal velocity under the other for the same input state. The only resolution is to prevent the two signals from acting on the same parameters, which motivates the Decoupled Diffusion Transformer architecture adapted from Wang et al. (2025c).

Why this is intellectually distinctive beyond the video domain. This insight generalizes to any generative modeling setting where a model must simultaneously learn from sparse real data (where averaging is necessary due to data scarcity) and from a rich teacher distribution (where mode-seeking is necessary for fidelity). The gradient conflict argument provides a principled criterion for when architectural decoupling is necessary: when two objectives have fundamentally different optimal predictors for the same input distribution. This is a more precise condition than the standard intuition of "multi-task learning sometimes causes interference."

Evidence anchoring. The ablation study in Table 2 provides the strongest evidence. The row labeled "w/o DDT dual heads" — which removes the decoupled architecture and trains a single velocity predictor with both SFT and teacher matching losses — shows "the largest drop across all metrics." This validates that the interference is real and that structural decoupling resolves it in a way that scalar loss weighting cannot. The qualitative results in Figure 4 further support the claim: SFT-only methods (single-head, mean-seeking only) are blurry; teacher-only methods (single-head, mode-seeking from distillation only) have local sharpness but global drift; the proposed decoupled method achieves both.

Innovation 3: A Short-Video Teacher Can Improve Long-Video Generation Without Needing to Understand Long-Range Context — Through Sliding-Window Marginal Matching

This is the paper's key architectural insight that makes the mode-seeking/mean-seeking decoupling operational. The clever move is recognizing that a short-video teacher, which was trained only on 5-second clips and has no capacity to evaluate multi-minute sequences, can nonetheless provide meaningful supervision for minute-scale generation — provided the supervision is applied at the teacher's native temporal scale through sliding-window marginal distributions.

What the field assumed before this paper. The standard approach to using a short-video teacher for long-video generation was either autoregressive distillation (CausVid, Yin et al., 2025; Self-Forcing, Huang et al., 2025b) or training-free extrapolation via noise rescheduling or positional embedding tricks (FreeNoise, Qiu et al., 2024; FreeLong, Lu et al., 2025a; InfinityRoPE, Yesiltepe et al., 2026). In the autoregressive distillation case, the teacher is queried on short segments generated one at a time, with the model conditioned on previous outputs to maintain continuity. In the extrapolation case, the teacher is never queried on long sequences — it generates short clips that are stitched or extended through inference-time modifications. Both approaches implicitly assume that the teacher's usefulness is limited to its native temporal horizon: it can guide local generation, but global structure must come from elsewhere.

What makes this contribution distinctive. The paper's conceptual innovation is to formalize the relationship between a long-video generator and a short-video teacher through the lens of induced marginal distributions. Specifically: a long-video generator induces a distribution over sliding L-frame windows (Equation 4-5). Enforcing that each of these window marginals matches the teacher's distribution — via D_KL(q_\Phi^{(k)} || p_{\text{teacher}}) — guarantees that every local segment of the long video looks realistic, without requiring the teacher to evaluate the full sequence. This is a distribution-level constraint, not a sample-level constraint: we don't need the teacher to judge whether frames 200-280 make sense in the context of frames 0-200; we only need the teacher to judge whether frames 200-280, viewed in isolation, look like a high-quality 5-second clip.

The innovation is recognizing that this is sufficient — that local realism at every window position, combined with global structure learned from real long videos via the SFT anchor, yields globally coherent and locally sharp videos. The teacher provides a regularity condition on the local statistics of the generated process; the SFT anchor provides the global trajectory.

Why the reverse KL is specifically chosen. The choice of reverse KL (mode-seeking) over forward KL (mean-seeking) is not incidental. A forward KL divergence D_KL(p_{\text{teacher}} || q_\Phi^{(k)}) would penalize the student for not covering all modes of the teacher — including modes that are irrelevant to the current long-video context. This would push the student toward exactly the averaging behavior that the SFT loss already induces. The reverse KL D_KL(q_\Phi^{(k)} || p_{\text{teacher}}) penalizes the student only for generating windows that are unlikely under the teacher, allowing the student to pick one sharp mode consistent with the global context. This is the mathematical formalization of the paper's "mode-seeking meets mean-seeking" framing: the SFT anchor establishes which modes are globally consistent, while the reverse-KL teacher matching forces the chosen mode to be locally sharp.

Why this is not obvious a priori. Prior work on long video generation treated the short-video teacher either as a local generator (in AR rollouts) or as a model to be modified for longer horizons (in extrapolation methods). The sliding-window marginal matching perspective is a different use of the teacher: not as a generator, but as a density critic that can only evaluate distributions on its native timescale. This is analogous to how GAN discriminators evaluate local patches rather than full images in PatchGAN — the insight that a critic with a limited receptive field can still enforce global quality if applied densely. The paper adapts this logic to the temporal domain with the additional twist that the critic is never trained on long sequences and cannot be.

Evidence anchoring. The quantitative results in Table 1 show that the proposed method achieves the best overall performance, outperforming both SFT-only approaches (which lack the teacher's local realism) and teacher-only autoregressive methods (which lack global coherence). The Gemini consistency scores particularly highlight the advantage over teacher-only methods like CausVid and InfinityRoPE, which the paper argues suffer from "blindness to long-context concepts." The ablation in Table 2 isolating "w/o sliding-window DMD" (which removes the teacher matching) shows degraded quality compared to the full model, confirming that the teacher matching contributes beyond what SFT alone provides.

Innovation 4: Verifier Over-Optimization and Distribution Collapse Are Inherent to Long-Video Teacher Distillation — the Decoupled Architecture Mitigates This by Separating Global Structure from Local Fidelity

This contribution is a diagnostic insight that emerges from the paper's analysis of why existing teacher-distillation approaches for long video generation fail in specific, characteristic ways. The paper documents distinct failure modes for different approaches — blurriness in SFT-only methods, autoregressive drift and over-saturation in teacher-only AR methods, and frozen/static content in sink-based extrapolation methods — and traces them to a common underlying dynamic: the instability that results when a single model must simultaneously maintain global coherence and local fidelity under conflicting optimization pressures.

What makes this diagnosis distinctive. The paper identifies a spectrum of failure modes that can be understood through the lens of gradient interference severity. At one extreme, pure SFT on long videos (LongSFT, MixSFT) produces globally coherent but locally blurry outputs because the mean-seeking L_2 loss averages away high-frequency detail under data scarcity. At the other extreme, pure teacher distillation through autoregressive rollouts (CausVid, Self-Forcing) produces locally sharp but globally drifting outputs because the teacher provides no long-range signal, and AR error accumulation compounds deviations over time. Sink-based methods like InfinityRoPE represent a degenerate solution to this tension: by anchoring generation to fixed frames, they prevent AR drift but at the cost of suppressing motion entirely, producing static or near-static videos. The paper's measured dynamic degree scores for InfinityRoPE in Table 1 confirm this quantitatively.

The proposed decoupled architecture resolves this spectrum by structurally preventing the two objectives from competing on the same parameters. The FM head handles global structure without ever receiving the mode-seeking signal that would over-optimize its velocity predictions. The DM head handles local fidelity without ever receiving the mean-seeking signal that would pull it toward averaging. The shared encoder learns representations that serve both, but each head's output is specialized to one objective.

Why this is more than an empirical observation. The paper is diagnosing a fundamental instability in the training dynamics of generative models applied to multi-scale temporal data. This connects to broader phenomena in generative modeling — mode collapse in GANs, reward hacking in RLHF, over-optimization of reward models — where a model exploits a proxy objective (in this case, the teacher's local density estimate) in ways that degrade the intended behavior (global coherence). The decoupled architecture can be understood as a form of structural regularization that prevents the mode-seeking objective from being applied to parameters responsible for global structure. This is a design principle that may generalize: when a generative model must satisfy constraints at multiple scales, and those constraints are enforced by objectives with different optimization characteristics (mean-seeking vs. mode-seeking, local vs. global), architectural separation of the objectives' influence may be necessary for stable training.

Evidence anchoring. Table 2 shows the ablation results. Removing the SFT anchor ("w/o SFT") — making the model rely purely on teacher matching — yields "competitive motion but worse global consistency and overall quality." Removing the teacher matching ("w/o sliding-window DMD") degrades local quality. Removing the decoupled architecture ("w/o DDT dual heads") produces the largest drop across all metrics. These three ablation conditions map cleanly onto the spectrum of failure modes observed in prior work: w/o SFT approximates the teacher-only AR regime (local sharpness, global drift), w/o DMD approximates the SFT-only regime (global coherence, local blur), and w/o dual heads produces a model that fails at both because gradient interference prevents either objective from being properly satisfied. The full model achieves the best performance because it structurally resolves the interference, allowing each objective to shape the parameters that matter for its domain.

5. Experimental Analysis

Evaluation Methodology

  • Dataset. The paper uses 200 prompts describing long videos and events as the test set, generating 30-second videos for evaluation. These prompts are not from a standard published benchmark — they are custom-curated for this work. Training data consists of more than 100,000 videos from public sources (Sekai dataset (Li et al., 2025c), a subset of MiraData (Ju et al., 2024)) plus filtered single-shot internet videos, with an average duration of 31 seconds and a temporal upper bound of 61 seconds (Appendix B). Videos are pre-processed into length-based buckets for dynamic batching, with variable-length training used to reduce padding waste.

  • Base model(s). All experiments use the Wan 2.1 1.3B model (Wang et al., 2025a) as the student backbone, with the frozen short-video teacher also being Wan 2.1 1.3B for fair quantitative comparison. The paper states that qualitative results using Wan 14B as both student and teacher are available on the supplemental website, but all quantitative tables (Tables 1, 2) use the 1.3B scale. This is significant because Wan 1.3B represents a relatively small model (1.3 billion parameters) — the paper's claims about closing the fidelity-horizon gap are demonstrated at this scale, with the 14B results presented only qualitatively, leaving an open question about whether the quantitative improvements hold at larger scales where the base model already has stronger priors.

  • Metrics. Two categories of metrics are used. VBench-Long metrics (Huang et al., 2024a, 2024b; Zheng et al., 2025) include: subject consistency (whether the same subject maintains appearance across frames), background consistency (whether scene backgrounds remain coherent), motion smoothness (temporal smoothness of motion trajectories), temporal flickering (high-frequency temporal artifacts), dynamic degree (amount of motion — not a quality metric per se but an indicator of whether the model generates static content), aesthetic quality (learned aesthetic scoring), and imaging quality (technical image quality including sharpness and artifacts). These are automated metrics computed using classifier-based evaluation, following the VBench protocol. Additionally, Gemini consistency is reported — a score from 0–100 produced by Gemini-3-Pro (an MLLM capable of video input) that evaluates semantic consistency while penalizing static videos (the full instruction prompt is provided in Appendix D: it explicitly instructs the model that "If the video is essentially a still image / frozen frame(s) with little-to-no motion or temporal change, do NOT give a high score"). This dual evaluation strategy — VBench for validated automated metrics plus Gemini for semantic consistency — is reasonable but note that Gemini scoring introduces dependence on a proprietary, potentially evolving API.

  • Baselines. The paper compares against four categories of approaches, with specific implementations:

    • Long-context SFT (LongSFT): the basic long-tuning strategy where short pretrained Wan 1.3B is fine-tuned on collected long video clips. This represents the simplest baseline.
    • Mixed-lengths SFT (MixSFT): the advanced industrial setup where videos of different lengths are jointly trained, representing models like HunyuanVideo (Kong et al., 2024), CogVideoX (Yang et al., 2024), and Seedance (Seawead et al., 2025). Both LongSFT and MixSFT use the same Wan 1.3B backbone as the proposed method.
    • Teacher-only autoregressive methods: CausVid (Yin et al., 2025) — an AR video diffusion model that distills from a short-video teacher; Self-Forcing (Huang et al., 2025b) — bridges the train-test gap in AR video diffusion; InfinityRoPE (Yesiltepe et al., 2026) — a sink-based extrapolation method for infinite video generation from autoregressive self-rollout. For CausVid and Self-Forcing, the paper uses the extrapolation method provided in CausVid to generate long videos. These baselines use teacher-only signals without ground-truth long-video supervision.

  • Generation budget / compute accounting. The paper does not explicitly define a unified compute budget in terms of FLOPs, generation steps, or wall-clock time. The implicit budget is the ability to generate a 30-second video at comparable quality. Different methods use different inference procedures: the proposed method uses few-step sampling (enabled by DMD distillation), while baselines use standard multi-step diffusion (LongSFT, MixSFT) or autoregressive rollouts (CausVid, Self-Forcing). The paper notes that the DM head is "directly capable of few-step inference, unlocking fast minute-scale video generation" (Section 3.7), but no inference-time step counts or wall-clock comparisons are reported in the quantitative tables. This is a notable gap — the claim of "fast" generation is not empirically benchmarked against baselines. The training compute budget is also not reported (GPU-hours, number of iterations, or total FLOPs), so the cost of the proposed training procedure relative to baselines cannot be assessed.

  • Cross-validation / statistical protocol. The paper does not report any cross-validation, statistical significance testing, or error bars for the quantitative results in Tables 1 and 2. Each metric in Table 1 is a single number per method, with no indication of variance across prompts, runs, or evaluation seeds. Given the 200-prompt test set, this is a meaningful limitation — differences of small magnitudes between methods (e.g., motion smoothness of 0.980 vs. 0.979) may not be statistically distinguishable. The three-best highlighting convention (first, second, third values color-coded) implicitly ranks methods but does not convey whether differences are significant. This is standard for the video generation subfield (VBench papers themselves report single numbers), but it limits the strength of comparative claims.

Main Quantitative Results

Comparisons Against Baselines (Table 1)

The headline result is that the proposed method ("Ours") achieves the best overall performance across nearly all VBench-Long metrics and the Gemini consistency score. The specific numbers from Table 1:

Subject consistency: Ours achieves 0.971 (ranked 2nd), compared to InfinityRoPE at 0.972 (ranked 1st) and CausVid at 0.970 (ranked 3rd). The differences are in the third decimal place — all methods perform similarly on this metric, with the exception of Self-Forcing (0.965, ranked 5th). This narrow spread (~0.007 range across all methods) suggests subject consistency may be near saturation for these models on this test set.

Background consistency: Ours achieves 0.980 (ranked 1st), with LongSFT at 0.979 (ranked 2nd) and MixSFT at 0.978 (ranked 3rd). Again, the spread is tiny (0.004 range), making ranking discrimination unreliable without confidence intervals.

Motion smoothness: Ours achieves 0.984 (ranked 3rd), behind MixSFT at 0.988 (ranked 1st) and LongSFT at 0.987 (ranked 2nd). This is noteworthy: SFT-only methods actually outperform the proposed method on motion smoothness, though the gap is again small (~0.004). This may reflect that the mode-seeking teacher alignment can introduce very slight temporal discontinuities at window boundaries, though the paper does not discuss this.

Temporal flickering: Ours achieves 0.977 (ranked 1st), compared to 0.976 (LongSFT and MixSFT tied for 2nd). The spread across all non-InfinityRoPE methods is 0.002, which is likely within evaluation noise.

Dynamic degree: Ours achieves 0.423 (ranked 2nd), with MixSFT at 0.433 (ranked 1st) and LongSFT at 0.400 (ranked 3rd). The larger range here (0.433 to 0.145 for InfinityRoPE) reveals a more discriminating metric. InfinityRoPE's very low dynamic degree (0.145) confirms the paper's claim that sink-based methods generate static content. CausVid (0.367) and Self-Forcing (0.381) fall between the SFT methods and InfinityRoPE, suggesting they sacrifice some motion to control AR drift. The proposed method preserves competitive dynamic degree (0.423) while improving quality metrics, supporting the claim that it avoids the static-content failure mode.

Aesthetic quality: Ours achieves 0.533 (ranked 1st), substantially ahead of MixSFT (0.479, ranked 2nd) and LongSFT (0.468, ranked 3rd). This is the largest gap in the VBench metrics — a 0.054 absolute improvement over the best SFT baseline. This metric aligns with the paper's central claim: decoupled teacher matching improves visual quality (sharpness, aesthetic appeal) that the blurry SFT outputs lack.

Imaging quality: Ours achieves 0.583 (ranked 1st), compared to MixSFT at 0.536 (ranked 2nd) and LongSFT at 0.522 (ranked 3rd). A 0.047 absolute improvement over the best SFT baseline. This metric (technical image quality including sharpness and artifacts) further supports the claim that the mode-seeking teacher alignment recovers high-frequency detail lost in SFT-only training.

Gemini consistency: Ours achieves 74.3 (ranked 1st), compared to MixSFT at 62.8 (ranked 2nd) and LongSFT at 61.4 (ranked 3rd). This ~12-point improvement over the best non-our method is the most discriminating result in the table and the strongest evidence for the paper's central thesis. The Gemini evaluator was explicitly instructed to penalize static videos, so the high score reflects both semantic consistency and adequate motion. The large gap between teacher-only methods (CausVid: 54.8, Self-Forcing: 53.4, InfinityRoPE: 50.8) and the proposed method confirms the paper's diagnosis: teacher-only methods achieve decent local metrics (VBench) but fail on semantic consistency when evaluated by a capable video-understanding model, because they lack the long-range grounding that long-video SFT provides.

The paper's self-reported analysis of these groupings (Section 4.2) organizes the takeaway as: SFT-only methods produce globally coherent but blurry outputs (low aesthetic/imaging quality despite high consistency metrics); teacher-only methods produce locally sharp but globally drifting or static outputs (low Gemini consistency despite competitive VBench metrics); the proposed method achieves both simultaneously, with the highest Gemini score and top or near-top VBench quality metrics.

Qualitative Results (Figures 3 and 4)

Figure 3 shows example frames from the proposed method across diverse scenarios (the Wan 1.3B model serving as both student and teacher). The paper claims these demonstrate generalization to "various scenarios" with both local fidelity and global coherence, and directs readers to the supplemental website for full video results and Wan 14B outputs.

Figure 4 provides the most informative side-by-side comparison. The paper identifies the following specific failure modes visible in the figure:

  • SFT baselines (LongSFT, MixSFT): in the top example, fine textures are "washed out, edges appear softened, and the foreground subject can collapse into an under-defined silhouette." In the bottom example (street-walk), SFT baselines show "weakened long-range camera/scene continuity, with noticeable viewpoint/scene inconsistencies across frames."

  • Teacher-only methods (CausVid, Self-Forcing): the paper observes that these "can inherit stronger local contrast from the short-video teacher" but "struggle to maintain realistic evolution over extended horizons." Specific artifacts include "over-saturation and reduced dynamics" or "conservative motion to avoid autoregressive error accumulation."

  • InfinityRoPE: demonstrates the static-content failure mode diagnosed in the paper, with "motion degradation" being "especially notable" and attributed to sink mechanisms that "attach generation to certain frames."

  • Ours: the paper claims simultaneous maintenance of "long-range scene/narrative consistency" and "crisp local appearance," with foreground subjects remaining "sharper and more consistently rendered across time" and backgrounds evolving "smoothly without the abrupt viewpoint shifts seen in SFT-only training or the motion collapse/pattern repetition commonly induced by teacher-only long rollouts."

Critical note on qualitative evaluation: all visual comparisons in Figure 4 are single representative frames from videos. The paper acknowledges this limitation by directing to the supplemental website for "dynamic video comparisons." Evaluating temporal coherence from still frames is inherently limited — the viewer cannot assess motion smoothness, flickering, or dynamic degree from the paper figures alone. This is a standard constraint of the format, not a flaw, but readers should understand that the paper's strongest temporal coherence claims rely on the video results and the quantitative metrics rather than the printed qualitative examples.

Ablation Results (Table 2)

Table 2 presents ablation of three components, with the same VBench + Gemini metrics as Table 1. The full model ("Ours") is compared against three ablated variants:

"w/o DDT dual heads": the most severe ablation. This removes the decoupled architecture and naively trains a single velocity predictor with both mean-seeking SFT and mode-seeking teacher alignment. The paper reports this causes "the largest drop across all metrics." Specific numbers from Table 2: Subject consistency drops from 0.971 to 0.964; background consistency from 0.980 to 0.973; motion smoothness from 0.984 to 0.977; temporal flickering from 0.977 to 0.972; dynamic degree drops from 0.423 to 0.340 (a substantial reduction, suggesting motion is suppressed); aesthetic quality drops from 0.533 to 0.436; imaging quality drops from 0.583 to 0.498; and Gemini consistency drops from 74.3 to 53.2 (a dramatic decline of ~21 points). This is the strongest empirical evidence for the paper's central claim about gradient interference — when forced through one head, the two objectives produce worse results than either alone, with the Gemini score falling close to the teacher-only baseline range.

"w/o sliding-window DMD": this removes the teacher matching entirely, reverting to pure SFT. The paper notes this "degrades the model into SFT-only." The Gemini score drops from 74.3 to 60.9 (close to LongSFT's 61.4), while aesthetic quality drops from 0.533 to 0.472 and imaging quality from 0.583 to 0.527. Dynamic degree actually increases slightly (0.423 to 0.455), consistent with SFT methods showing higher dynamic degrees in Table 1. This ablation confirms that the teacher matching is responsible for the quality improvements beyond what SFT alone can achieve.

"w/o SFT": this removes the supervised flow-matching anchor on real long videos, relying only on sliding-window teacher alignment. The paper reports this yields "competitive motion but worse global consistency and overall quality." The Gemini score drops from 74.3 to 56.8 (better than pure teacher-only baselines in Table 1, but substantially worse than the full model), while aesthetic quality and imaging quality remain relatively competitive (0.527 and 0.571 respectively). Dynamic degree is close to the full model (0.420 vs. 0.423). This ablation confirms the paper's claim that a short-video teacher is "inherently blind to minute-scale narrative structure and cannot substitute for long-video supervision" — local quality can be maintained, but global semantic consistency degrades without the SFT anchor.

Non-obvious pattern in the ablation results: the "w/o DDT dual heads" configuration produces worse Gemini consistency (53.2) than "w/o SFT" (56.8), and substantially worse quality metrics (aesthetic: 0.436 vs. 0.527; imaging: 0.498 vs. 0.571). This means that receiving both signals through a single head is worse than receiving only the teacher matching signal. The gradient interference is not just additive — it actively degrades the model below what either signal alone can achieve. This is the strongest empirical validation of the paper's architectural claim, and it is not merely a matter of tuning failure: the two objectives are fundamentally incompatible when routed through shared output parameters.

Ablation limitation: the paper reports only aggregate metrics (averaged across all 200 prompts). No difficulty-stratified or content-stratified ablation is provided. It would be informative to see whether the dual-head advantage is uniform across different types of scenes (static vs. high-motion, indoor vs. outdoor, single-subject vs. multi-subject) or whether the gradient interference is particularly severe in specific regimes.

Critical Assessment

Claim 1: The method closes the fidelity-horizon gap by jointly improving local sharpness/motion and long-range consistency

Assessment: Supported with meaningful caveats. The quantitative evidence is strongest for the joint improvement claim on the Gemini consistency metric (+11.5 points over MixSFT, the best non-our method; Table 1) and the aesthetic/imaging quality metrics (+0.054 and +0.047 absolute improvements over MixSFT; Table 1). These are the largest gaps in the table and are consistent with the paper's narrative. However, several qualifications apply:

  • Motion smoothness is actually slightly worse than SFT-only methods (0.984 for Ours vs. 0.988 for MixSFT; Table 1). The paper does not discuss this inversion — the proposed method's mode-seeking teacher alignment may introduce subtle temporal discontinuities at window boundaries, manifesting as marginally reduced motion smoothness. The gap is tiny (0.004) and likely within noise, but the paper's claim of "improving motion" is not strictly supported for the motion smoothness metric specifically.

  • Dynamic degree is slightly lower than MixSFT (0.423 vs. 0.433; Table 1). Again, a small margin, but the highest-motion method is MixSFT, not the proposed approach. The paper's claim that teacher-only methods produce static content (validated for InfinityRoPE at 0.145) does not extend to the comparison with SFT baselines, which maintain competitive or higher motion metrics.

  • The "horizon" is fixed at 30 seconds. The paper claims minute-scale generation capability (title, Section 1, Section 3.7), but all quantitative evaluation is on 30-second videos. The 30-second horizon is 6× the teacher's 5-second native window, which is a meaningful extension, but it is not "minutes" (which would imply 60+ seconds or longer). The claim of bridging the fidelity-horizon gap is demonstrated for a 6× temporal extension, not for the 12× or greater extension that "minute-scale" implies. The qualitative results and the Wan 14B experiments (supplemental website, not quantitatively evaluated) may show longer generations, but the paper's strongest evidence stops at 30 seconds.

  • Single test set of 200 prompts. This is a modest size. The prompts are custom-curated (not a standard benchmark), which makes replication difficult and raises questions about whether they were selected or filtered in ways that favor the proposed method. The paper does not describe the prompt curation process.

Claim 2: Local realism can be inherited from a short-video teacher without requiring additional short-video data

Assessment: Supported, with a crucial architectural condition validated. The ablation "w/o sliding-window DMD" (Table 2) shows that removing teacher matching degrades quality metrics (aesthetic: 0.533 → 0.472, imaging: 0.583 → 0.527), confirming that the teacher provides a quality signal beyond what SFT alone can achieve. The teacher is frozen and queried only on student-generated windows — no short-video training data is accessed, only the teacher model. This is the strongest and cleanest result in the paper because the ablation directly tests the claimed mechanism.

However: the paper does not ablate the quality of the teacher. All experiments use Wan 1.3B as the teacher. Would a weaker teacher (e.g., a smaller model, or a model trained on less data) still provide useful local realism signals? Would a stronger teacher provide proportionally more benefit? These questions are not addressed. The claim that local realism can be inherited "without requiring additional short-video data" is true in the literal sense (no data is accessed), but the teacher itself was trained on web-scale short-video data — the method is inheriting the fruits of that data through the teacher's weights. This is not a weakness (it is the whole point), but it means the method's effectiveness is bounded by the teacher's quality, which the paper does not characterize.

Additionally: the sliding-window mechanism requires the student and teacher to share the same frame rate, resolution, and VAE latent space. This is not a limitation of the claim itself, but it constrains applicability — the method works when a high-quality short-video teacher is available in the same latent space, which is true for Wan but may not be for other model families where short-video teachers use different architectures or latent representations.

Claim 3: Global coherence must be simultaneously anchored through supervised flow matching on real long-form clips, and routing the two signals through separate heads is necessary

Assessment: Strongly supported by the ablation evidence. The "w/o SFT" ablation (Table 2) shows that removing long-video supervision degrades Gemini consistency from 74.3 to 56.8, confirming that the teacher alone cannot provide global coherence. The "w/o DDT dual heads" ablation shows the largest degradation across all metrics, confirming that structural decoupling is necessary — naively combining both losses through a single head produces Gemini consistency of 53.2, which is worse than either signal alone (56.8 for w/o SFT, 60.9 for w/o DMD). This is the paper's strongest and most intellectually significant result.

However: the paper does not investigate alternative architectures for resolving gradient interference. The Decoupled Diffusion Transformer with separate heads is one solution, but there exist others — gradient projection methods (projecting conflicting gradients onto orthogonal subspaces), multi-task learning with task-specific normalization, or alternating optimization (train one objective for N steps, then the other). The paper demonstrates that DDT works, but does not demonstrate that it is the best or most efficient solution to the gradient interference problem. The ablation only compares against "no decoupling" (single head), not against alternative decoupling strategies.

Claim 4: The DM head serves as a fast, few-step sampler for inference

Assessment: Stated as a benefit but never quantitatively demonstrated. The paper claims in Section 3.7 that "the output model with DM head is directly capable of few-step inference, unlocking fast minute-scale video generation," but the experimental section reports no inference speed comparisons — no step counts, no wall-clock times, no FLOPs-per-generation measurements. The comparison against baselines in Table 1 uses final output quality, not generation speed. The LongSFT, MixSFT, CausVid, Self-Forcing, and InfinityRoPE baselines each have different inference procedures with different computational costs, but this is not discussed or controlled for.

This is a significant gap. The "fast" claim is central to the paper's practical motivation (Section 1: "fast long video synthesis at inference time"), and DMD distillation typically achieves 4–8 step generation versus 50+ for standard flow matching — a genuine speedup. But without reporting the actual step count or wall-clock comparison, the reader cannot assess the magnitude of the speedup or whether the quality improvements come at a speed cost. If the DM head requires 8 steps and the SFT baselines use 25, the speedup is ~3×, not the ~10× sometimes associated with DMD. If the baselines can also be distilled to few steps with standard techniques, the claimed advantage of the DM head being "directly capable" of few-step inference would be less distinctive.

Claim 5: The method is orthogonal to causal autoregressive methods and could be combined with them

Assessment: Plausible but untested. The paper states this in Section 5 and Appendix E as a direction for future work, not as a demonstrated result. No experiments combine the decoupled bidirectional model with causal AR training or distillation into a causal sampler. The claim of orthogonality is conceptual (the approach addresses training methodology, causal AR addresses inference paradigm) but not empirically validated. This is a standard scope limitation, not a flaw, but the language in Section 4 ("we note that our method is orthogonal to causal AR models and can be used alongside them") could be read as implying demonstrated compatibility, which it is not.

Missing Experiments and Baselines That Would Strengthen the Paper

  1. Inference speed comparison: Report number of function evaluations, wall-clock time, or FLOPs for generating a 30-second video with the proposed method versus each baseline. This is essential for the "fast generation" claim.

  2. Scaling with teacher quality: Ablate by using a weaker teacher (e.g., an earlier checkpoint of Wan, or a smaller model) to test whether the benefit of teacher matching scales with teacher quality or whether any sufficiently good short-video model suffices.

  3. Longer horizon evaluation: Extend quantitative evaluation to 60-second or 90-second videos to validate the "minute-scale" claim. The 30-second horizon tests a 6× extension beyond the teacher's 5-second window; scaling to 60 seconds (12×) would test whether the benefits hold at genuinely minute-scale durations.

  4. Diversity evaluation: The paper focuses on fidelity and coherence, but generative models can achieve high fidelity at the cost of diversity (mode collapse). No diversity metrics (e.g., FVD with diversity components, or coverage of generated content relative to a reference distribution) are reported. The mode-seeking reverse KL is explicitly designed to reduce diversity (concentrating on teacher modes), which is desirable for fidelity but could produce repetitive outputs across different prompts or random seeds. This tradeoff is not evaluated.

  5. Statistical significance: Report confidence intervals or standard deviations across the 200-prompt test set, particularly given the small metric gaps in VBench scores. Rank-ordering methods by raw scores without variance estimates overstates the reliability of the ordering.

  6. Prompt sensitivity: Evaluate whether the method's advantage is uniform across prompt types (static scenes vs. high-motion, single-subject vs. multi-subject, indoor vs. outdoor) or concentrated in specific regimes. The difficulty-stratified analysis that was central to the reference example paper's contribution — showing that methods perform differently on easy vs. hard problems — is absent here, and would significantly strengthen the diagnostic value of the results.

  7. Training cost: Report GPU-hours or total training iterations for the proposed method versus baselines. The dual-minibatch training procedure (SFT minibatch + on-policy teacher matching minibatch with 5-step fake score estimator retraining) is substantially more complex than standard SFT. Quantifying this cost would help practitioners assess the practical tradeoff.

6. Limitations and Trade-offs

Inference Speed Claims Are Never Empirically Benchmarked

The assumption or constraint. The paper positions the DM head's few-step sampling capability as a central practical benefit, stating in Section 3.7 that the output model is "directly capable of few-step inference, unlocking fast minute-scale video generation" and in Section 1 that this enables "fast long video synthesis at inference time." However, no inference-time metrics are reported anywhere in the experimental section. There is no measurement of number of function evaluations (NFE), wall-clock time, FLOPs-per-generation, or any speed comparison against baselines. The baselines themselves use different inference procedures — LongSFT and MixSFT use standard multi-step flow matching, CausVid and Self-Forcing use autoregressive rollouts, and InfinityRoPE uses a custom extrapolation scheme — but their relative computational costs are never quantified or discussed.

The consequence. The reader cannot assess the magnitude of the "fast" claim. DMD distillation typically achieves 4–8 NFEs versus 50+ for standard flow matching, which represents a genuine speedup. But the paper provides no evidence that: (a) the baselines could not also be distilled to similar step counts using standard techniques (in which case the DM head's few-step capability would not be distinctive to this method), (b) the DM head's quality improvements do not come at a higher NFE than is standard for distilled models, or (c) the per-step cost of the DM head (which operates on full long-video latents with full-range attention) does not offset the step-count reduction relative to baselines that might use cheaper per-step architectures. Without this data, the "fast generation" claim — which appears in the abstract as "resulting in a few-step fast long video generator" — is an unverified assertion rather than an empirically supported finding.

What evidence exists in the paper. None. The paper provides zero inference speed measurements.

Mitigation status. The paper does not acknowledge this as a gap. The "fast" language appears in Section 1 (contributions list), Section 3.7 (inference procedure description), and Section 4 (where it is not referenced in the quantitative results). The supplementary website (referenced for video results and Wan 14B qualitative outputs) may contain speed metrics, but they are not in the paper text or the appendices provided.

Quantitative Evaluation Stops at 30 Seconds; "Minute-Scale" Claim Is Not Verified

The assumption or constraint. The paper's title, abstract, and introduction all frame the contribution around minute-scale generation — "Scaling video generation from seconds to minutes," "enables the synthesis of minute-scale videos," "fast minute-scale video generation." However, all quantitative evaluation in Tables 1 and 2 is conducted on 30-second videos. The 30-second horizon represents a 6× extension beyond the teacher's native 5-second window, which is a meaningful scaling factor, but it falls substantially short of the one-minute mark (60 seconds, or 12× extension) that the paper's framing implies. The training data includes videos with a temporal upper bound of 61 seconds (Appendix B), so longer generations are technically possible, but their quality is never measured.

The consequence. The central claim — that the method enables minute-scale video generation — rests entirely on qualitative inspection of outputs that are not quantitatively evaluated at the minute scale. The gap between 30 seconds and one minute may seem like a factor of 2, but the difficulty of long-video generation likely scales nonlinearly with duration. Error accumulation, coherence maintenance, and computational cost all compound as sequence length increases. The 30-second results demonstrate that the method works at a 6× extension; whether the benefits persist at 12× or greater is unknown. This is particularly relevant because the paper explicitly diagnoses existing methods as failing due to error accumulation over long horizons (Section 2 and Section 4.2 analysis of AR methods), so the method's own behavior at genuinely long horizons is important to characterize.

What evidence exists in the paper. The paper states that "We... generate 30-second videos" for evaluation (Section 4.1). The qualitative results in Figure 3 are described as demonstrating generalization, but their duration is not specified per-video. The training data extends to 61 seconds (Appendix B), suggesting longer generation is architecturally possible, but no metrics are reported. The Wan 14B qualitative results on the supplemental website may include longer videos, but they are not linked to any quantitative assessment.

Mitigation status. The paper does not acknowledge this as a limitation. The framing language ("minute-scale") is used throughout without qualification that the quantitative evidence covers only the 30-second point. This is not exactly a factual error — 30 seconds is within the "minute-scale" range — but it overstates the empirical coverage of the strongest evidence, which stops at half a minute.

The Ablation Design Tests Component Presence But Not Architectural Alternatives

The assumption or constraint. The ablation study (Table 2) tests three configurations: the full model, removal of dual heads (single velocity predictor with both objectives), removal of teacher matching (SFT-only), and removal of SFT anchor (teacher-only). This design establishes that all three components are necessary for the best results — removing any one degrades performance. However, it does not test whether the Decoupled Diffusion Transformer (DDT) is the best architecture for resolving the identified gradient interference, or even whether alternative decoupling strategies could achieve comparable or better results.

The paper's central theoretical claim is that mean-seeking and mode-seeking objectives produce gradient interference when routed through a single velocity predictor, and that the DDT architecture resolves this. The "w/o DDT dual heads" ablation validates that a single head is worse. But the space of possible decoupling strategies is large and includes: gradient projection methods (projecting conflicting gradients onto orthogonal subspaces before applying them to shared parameters), task-specific normalization layers (where each objective has its own normalization statistics within a shared architecture), alternating optimization (train SFT for N steps, then teacher matching for M steps, which would prevent simultaneous gradient interference without requiring separate heads), or separate encoders with a shared latent bottleneck (the inverse of DDT, where heads are shared but encoders are separate). None of these are tested.

The consequence. The paper establishes that DDT works but not that it is the best or most efficient solution. A practitioner implementing this approach may find that simpler alternatives — particularly alternating optimization, which requires no architectural modification — achieve comparable results with less implementation complexity. The ablation also does not characterize the computational overhead of the dual-head architecture: the DM head and FM head are described as "lightweight" transformer decoders (Section 3.3), but no parameter counts, FLOPs comparisons, or memory measurements are reported relative to a single-head architecture. The "w/o DDT dual heads" variant presumably has fewer parameters but worse performance; whether a larger single-head model could match the dual-head performance with equivalent total capacity is not tested.

What evidence exists in the paper. Table 2 shows the "w/o DDT dual heads" row with degraded performance. Appendix A describes the sequence parallelism setup (DeepSpeed Ulysses with group sizes of 4 for A100, 2 for GB200) and notes the implementation is "built on top of the FastGen repository," but provides no architectural specifications for the decoder heads (layer counts, hidden dimensions, parameter counts relative to the encoder). Section 3.3 states the heads are "lightweight" but does not quantify this.

Mitigation status. The paper does not acknowledge this as a limitation. The ablation is presented as validating that decoupling is necessary, and the DDT adaptation is treated as the natural implementation of that insight. The paper does not claim that DDT is optimal, but the absence of any architectural baselines means the reader cannot assess the efficiency of the specific decoupling strategy used.

No Diversity Evaluation; Mode-Seeking Objective May Induce Mode Collapse

The assumption or constraint. The paper's entire evaluation framework — VBench-Long metrics (subject consistency, background consistency, motion smoothness, temporal flickering, dynamic degree, aesthetic quality, imaging quality) and the Gemini consistency score — measures fidelity and coherence of individual generated videos. None of these metrics assesses diversity: whether the model produces varied outputs across different prompts, different random seeds for the same prompt, or different temporal positions. The Distribution Matching head is trained with a mode-seeking reverse-KL divergence, which explicitly encourages the student to concentrate probability mass on the teacher's high-density modes. This is the intended behavior for local realism — it prevents the averaging blur of mean-seeking objectives — but it creates a known tradeoff: mode-seeking objectives can induce mode collapse, where the model produces a narrow range of outputs that are individually sharp but collectively repetitive.

The paper's methodology means this tradeoff is never measured. The VBench metrics are computed on per-video quality; if the model produced exactly the same high-quality 30-second video for every prompt, it would score perfectly on all VBench metrics and potentially well on Gemini consistency (since the video would be internally coherent). No metric captures whether the outputs are meaningfully different from each other or from the teacher's training distribution in undesirable ways.

The consequence. A practitioner deploying this method for applications requiring diverse outputs — story generation with varied scenes, interactive world modeling with non-deterministic behavior, data augmentation for downstream training — may find that the model produces sharp but repetitive content. The "w/o SFT" ablation (Table 2) is the closest proxy for pure mode-seeking behavior (teacher matching only, no long-video data anchor), and while it achieves competitive VBench quality scores (aesthetic: 0.527, imaging: 0.571), its Gemini consistency drops to 56.8. This suggests the SFT anchor provides some diversity through the mean-seeking signal, but the balance point between diversity and fidelity is not characterized. The weight λ_seg controlling the relative strength of the mode-seeking and mean-seeking objectives is never reported, and no sweep over this hyperparameter is shown to characterize the diversity-fidelity tradeoff curve.

What evidence exists in the paper. None. No diversity metrics (FVD with diversity components, coverage, precision/recall for generative models, or even simple pairwise similarity between outputs) are reported. The 200-prompt test set could be used to measure output diversity across prompts, but this analysis is not performed.

Mitigation status. The paper does not acknowledge this as a limitation. The mode-seeking property is framed as entirely positive ("encourages the student to concentrate its mass on the teacher's high-fidelity modes rather than averaging over them," Section 3.2), with no discussion of the potential downside. This is a conceptual gap: the reverse-KL objective is described mechanistically (what it encourages) but not normatively (whether encouraging concentration on a subset of modes is always desirable for long-video generation, where diverse plausible futures may be expected from a single prompt).

Training and Evaluation Are Specific to the Wan 1.3B Model Family; Generalizability to Other Architectures or Scales Is Untested

The assumption or constraint. All quantitative experiments use the Wan 2.1 1.3B model as both the student backbone and the frozen teacher (Section 4.1). The Wan 14B model is mentioned as having qualitative results on the supplemental website, but no quantitative comparison is provided in the paper. The Wan architecture — including its VAE latent space design, DiT backbone, and specific training recipe — may have properties that interact favorably with the proposed method in ways that other model families (e.g., HunyuanVideo, CogVideoX, Sora-style models with different latent representations or attention patterns) might not replicate.

Several architectural details are Wan-specific. The image-latent/video-latent boundary issue (Appendix C) and its solution via VAE round-trip reconstruction are described as following LongLive (Yang et al., 2026) and being effective for "both causal AR models... and non-causal bidirectional models like ours." But the existence of this issue at all depends on the VAE's distinction between image and video frame latents — other VAEs may not have this property, or may have different boundary artifacts that require different mitigation. The sliding-window DMD mechanism assumes the teacher can evaluate arbitrary 5-second windows from the student's latent space; this requires the student and teacher to share the same VAE, same frame rate, and same spatial resolution. The paper is transparent that Wan serves as both student and teacher ("for fair comparison"), but this also means the method is tested in a regime where student and teacher architectures and latent spaces are perfectly matched — the most favorable possible case.

The consequence. A practitioner working with a different base model family cannot assume that the reported gains will transfer. If the teacher model uses a different VAE or operates at a different frame rate, the sliding-window mechanism may not be directly applicable without latent-space alignment. If the base model's architecture does not cleanly support decoupled heads (e.g., a model where the velocity prediction is tightly integrated with the denoising backbone rather than exposed as a separable decoder), architectural modification may be more invasive than the paper's "lightweight" framing suggests. Additionally, the paper's claim that the method bridges the fidelity-horizon gap is demonstrated at the 1.3B parameter scale — a relatively small model by contemporary standards. Larger models may have stronger internal priors for both local realism (reducing the incremental benefit of teacher matching) and long-range coherence (reducing the incremental benefit of the SFT anchor relative to the base pretrained model), potentially narrowing or eliminating the advantage of the proposed method. The paper's qualitative Wan 14B results (supplemental website) may partially address this, but without quantitative metrics at the larger scale, the scalability of the benefits is unverified.

What evidence exists in the paper. Section 4.1 states: "We trained our methods on both the Wan 1.3B model and the Wan 14B model. For fair comparison, we use Wan 2.1 1.3B throughout our quantitative and qualitative comparisons... We refer to our supplementary website for qualitative results on the 14B model." The Wan 14B quantitative results are absent from Tables 1 and 2. The 200-prompt test set, custom training data curation, and specific training hyperparameters (batch sizes, learning rates, sequence parallelism configurations in Appendix A) are all described in terms of the Wan 1.3B setup.

Mitigation status. The paper does not acknowledge this as a limitation. The choice to use Wan 1.3B for quantitative evaluation is justified by "fair comparison" (Section 4.1), and the existence of Wan 14B qualitative results is mentioned. The paper does not claim generalizability to other model families, but the framing language in Section 1 ("our approach utilizes...", "our method effectively closes...") is absolute rather than conditional on the Wan architecture, and the contribution statements do not qualify their scope to the tested model family.

Training Compute Overhead and Hyperparameter Sensitivity Are Not Quantified

The assumption or constraint. The proposed training procedure is substantially more complex than standard SFT fine-tuning. Each training iteration requires: (1) a forward pass of real long videos through the encoder and FM head for the SFT loss; (2) an on-policy generation step where the student (using the DM head) produces full long-video samples; (3) extraction and noising of sliding windows from these samples; (4) querying the frozen short-video teacher on each window; (5) training a fake score estimator v_fake for 5 steps on the student's generated windows; (6) computing and backpropagating the DMD/VSD gradient surrogate through the DM head and shared encoder. This involves three models being optimized or queried (student encoder + two heads, teacher, fake score estimator) with a two-minibatch structure per iteration. The paper provides no information about the total training time, GPU-hours consumed, convergence behavior, or how these compare to the training cost of the baselines.

Additionally, several hyperparameters are introduced whose values and sensitivity are not reported: the scalar weight λ_seg balancing the SFT loss and teacher matching gradient (Equation 15), the number of sliding windows sampled per long video for teacher matching, the stride between windows, the exact number of inference steps used for on-policy generation during training, the learning rates for the encoder and two heads (which may need different values since they receive different gradient signals), and the specific DMD/VSD weighting function λ(t) absorbed into the gradient surrogate. The fake score estimator architecture and training details (beyond "5 steps of score matching") are not specified.

The consequence. A practitioner attempting to replicate or deploy this method faces significant uncertainty about training cost and tuning difficulty. The two-minibatch structure and on-policy generation step make each training iteration more expensive than a standard SFT iteration, but without cost measurements, the practitioner cannot assess whether the quality improvements justify the overhead. The sensitivity of results to λ_seg is particularly important: this weight controls the balance between global coherence (SFT anchor) and local fidelity (teacher matching), and the optimal value likely depends on the quality of the long-video data, the teacher quality, and the target horizon. If the method is highly sensitive to this hyperparameter, deployment on new model families or datasets would require expensive tuning. Conversely, if the method is robust across a wide range of λ_seg values, that would strengthen the practical case but is not demonstrated.

What evidence exists in the paper. The paper provides almost none of this information. Appendix A mentions use of DeepSpeed Ulysses, dynamic batching with length-based buckets, and the FastGen repository, but provides no training duration, iteration counts, learning rates, or hyperparameter values. The λ_seg weight is introduced in Equation 15 but never assigned a numerical value or discussed in the experimental section. The ablation in Table 2 tests component presence/absence (binary removal of dual heads, teacher matching, or SFT) but does not sweep over λ_seg or other continuous hyperparameters. The fake score estimator is described in Section 3.4 as trained "for 5 steps in between the student updates" but its architecture (separate small model? head on the shared encoder? something else?) is not specified.

Mitigation status. The paper does not acknowledge this as a limitation. The training procedure is described in sufficient detail to understand the algorithm (Sections 3.4–3.6) but not to reproduce it at a specific cost or to assess its sensitivity to hyperparameter choices. This is a common limitation in ML papers focused on methodology rather than systems, but it is particularly consequential here because the method's practical value proposition — better quality at acceptable training cost — cannot be evaluated from the information provided.

7. Implications and Future Directions

How This Work Changes the Landscape

This paper introduces a diagnostic framework — not a single architectural trick — that reframes how the field should think about scaling video generation across temporal horizons. The core diagnostic is that long video generation is extrapolation, not interpolation, and that the field's dominant training strategy of mixing video lengths implicitly assumes the wrong analogy. This matters because it explains a pattern of systematic failures across prior work in a unified way: SFT-only methods lose local fidelity (blurriness from averaging under data scarcity), teacher-only methods lose global coherence (AR drift or static content from lacking long-range signal), and naive combination destroys both (gradient interference between mean-seeking and mode-seeking objectives). The paper provides the first empirical demonstration that these failure modes are structural — they arise from the mathematical properties of the objectives themselves — and that resolving them requires architectural decoupling, not better hyperparameter tuning.

The field-level shift is this: before this paper, the default mental model for long-video training was "take a short-video model, train it on mixed-length data, and hope." This paper shows that hope is not a strategy — and gives practitioners a concrete division of labor: scarce long videos teach global narrative structure (the FM head), a frozen short-video teacher enforces local realism on its native timescale (the DM head via sliding-window reverse-KL), and separate decoder heads prevent gradient interference (the DDT architecture). This is a recipe, not a prayer.

The paper reconciles the apparent contradiction between work showing that teacher distillation helps short-term quality (CausVid, Self-Forcing) and work showing that teacher-only methods fail at long horizons (InfinityRoPE's static outputs, AR drift). Both observations are correct, but they operate at different temporal scales: the teacher provides a valid signal within its native ~5-second window, which is why local quality metrics are competitive for teacher-only methods in Table 1, but the teacher is blind to anything beyond that window, which is why Gemini consistency scores collapse (54.8 for CausVid, 50.8 for InfinityRoPE vs. 74.3 for the proposed method). The resolution is not to choose between teacher distillation and long-video supervision, but to route each signal where it is competent: the teacher on local windows, real long videos on global structure.

Several research directions become more attractive in light of this work. The "video length soup" approach — training a single model on all available data regardless of duration — now looks like a compromise driven by engineering convenience rather than a principled design choice. The paper's results suggest that future industrial video models should adopt decoupled architectures with dedicated objectives for different temporal scales, rather than hoping that a unified loss function will magically reconcile incompatible signals. Training-free extrapolation (FreeNoise, FreeLong, Riflex) faces a sharper challenge: the paper's diagnostic implies that these methods are fundamentally bounded because they cannot inject the long-range information that only real long videos provide. The teacher sends no signal about what should happen at frame 300, so no inference-time trick can create that information. This doesn't make extrapolation methods useless — they remain valuable when long-video data is entirely unavailable — but it sets a hard ceiling on their coherence at extended horizons.

Verifier/distillation quality as the bottleneck emerges as a parallel insight to what we see in the LLM test-time compute literature. The paper's method works because the short-video teacher is a high-quality local critic. A weak teacher would provide noisy matching gradients, and the DM head's few-step generation capability is bounded by what the teacher can assess. This redirects attention toward building better short-video models as a prerequisite for better long-video generation, which is a different investment strategy than scaling long-video data collection directly. The return on improving short-video teacher quality may be higher than the return on collecting marginally more long-form training data, especially given the extreme scarcity of the latter.

The paper also makes autoregressive teacher distillation look more fragile than previously appreciated. The dynamic degree scores in Table 1 tell a clear story: CausVid (0.367) and Self-Forcing (0.381) sacrifice motion to control drift, while InfinityRoPE (0.145) suppresses it almost entirely. The proposed method achieves 0.423 — competitive with the best SFT method (MixSFT at 0.433) — while maintaining both higher quality and higher Gemini consistency. This suggests that the drift-motion tradeoff in AR rollouts is not a fundamental limitation of long-video generation per se, but a limitation of using teacher-only signals. When global structure is separately anchored through real long videos, the mode-seeking head doesn't need to compromise motion for stability because stability comes from the shared encoder's long-range representations, not from conservative local generation.

Follow-Up Research This Work Enables

Quantifying the diversity-fidelity tradeoff under mode-seeking objectives. The paper uses a reverse-KL divergence for teacher matching, which is explicitly mode-seeking — it encourages concentration on high-density teacher modes. This is the right choice for local fidelity, but it likely reduces output diversity in ways the paper never measures. A strong follow-up would evaluate the proposed method on diversity metrics (per-prompt output variation across seeds, coverage of the teacher's mode distribution, FVD with diversity components, or precision-recall for generative video models) while sweeping the λ_seg weight that balances the mean-seeking SFT anchor against the mode-seeking DM head. The hypothesis is that higher λ_seg improves fidelity at the cost of diversity, and the ablation results already hint at this: the "w/o SFT" variant (pure mode-seeking) achieves competitive VBench quality (aesthetic: 0.527, imaging: 0.571) but its Gemini consistency drops to 56.8, suggesting it may be producing locally sharp but semantically narrow outputs. Characterizing the Pareto frontier between fidelity and diversity would tell practitioners how to set λ_seg for their application (film generation wants diversity, world simulation may tolerate less).

Scaling the method to genuinely minute-scale horizons with quantitative evaluation. The paper's title and framing promise minute-scale generation, but all quantitative evaluation stops at 30 seconds — a 6× extension beyond the teacher's 5-second window. The logical follow-up is to reproduce the full Table 1 evaluation at 60-second and 90-second horizons, keeping the identical test prompts (extended temporally) and metrics. The key questions are: does the Gemini consistency advantage of the proposed method grow, shrink, or stay constant as horizon increases? Does the quality gap over SFT baselines persist, or do SFT methods catch up at longer horizons once blurriness averages out over more frames? Do AR-based teacher-only methods experience compounding degradation (error accumulation) that makes the gap widen nonlinearly? The paper's training data already extends to 61 seconds (Appendix B), so this experiment is architecturally feasible without additional data collection — it is purely an inference-time study that would substantially strengthen or appropriately bound the "minute-scale" claim.

Testing the gradient interference hypothesis under alternative decoupling strategies. The paper demonstrates that dual DDT heads outperform a single head (Table 2, "w/o DDT dual heads"), but does not test whether other decoupling strategies achieve similar gains with less architectural complexity. A controlled comparison should test: (a) alternating optimization (train SFT for N steps, then DM for M steps, with a single shared head), which separates the gradient signals temporally rather than architecturally; (b) gradient projection (projecting the SFT and DM gradients onto orthogonal subspaces before applying them to a single shared head), which separates the update directions geometrically; and (c) a model with separate encoders but a shared head (the inverse of DDT), which tests whether representation isolation or output isolation matters more for resolving the interference. The alternating optimization baseline is particularly important because it requires zero architectural modification — if it works as well as DDT, the paper's architectural contribution is weaker, but the diagnostic insight (that the two objectives interfere) would be even more strongly validated. The Gemini consistency metric (which showed the largest gap between single-head and dual-head: 53.2 vs. 74.3) would be the primary endpoint, since it most sensitively captures global coherence.

Evaluating teacher quality scaling laws for long-video generation. The paper uses Wan 1.3B as the frozen teacher, and the "w/o sliding-window DMD" ablation (Table 2) confirms that the teacher provides a quality signal beyond SFT alone. But how does the benefit scale with teacher quality? A scaling study would ablate the teacher across a range of model sizes (e.g., Wan 1.3B, 7B, 14B, and a smaller or earlier-checkpoint variant as a weak teacher) while keeping everything else fixed. The hypothesis is that stronger teachers provide larger quality gains, but with diminishing returns — and critically, that even a relatively weak teacher (trained on modest short-video data) provides most of the benefit over no teacher at all. If true, this would make the method accessible to practitioners who lack state-of-the-art short-video teachers. If false (benefits only appear with near-frontier teachers), it would limit applicability to well-resourced labs. The aesthetic quality and imaging quality metrics from VBench would be the primary endpoints, since these capture the local realism that teacher matching is designed to impart.

Stress-test: does the method transfer to model families with different VAE latent spaces? The paper's experiments all use Wan 2.1, where the student and teacher share the same VAE, frame rate, and latent space. The image-latent/video-latent boundary issue (Appendix C) is solved via a VAE round-trip that works for Wan's latent structure, but other VAEs (e.g., those in HunyuanVideo, CogVideoX, or Sora-style models) may have different latent representations that break the sliding-window mechanism. A transfer study would implement the method using a different base model family (e.g., HunyuanVideo 1.5 as the teacher, with its own architecture as the student, or a cross-family setup where the teacher is Wan and the student is a different architecture with a latent-space adapter). The key measurement is whether the benefits persist when the teacher and student operate in different latent spaces, and what adapter complexity is needed. A negative result (the method fails to transfer) would not invalidate the paper's contributions but would appropriately scope them to the Wan family and motivate research on latent-space-agnostic distribution matching.

Combining the decoupled bidirectional model with causal autoregressive inference. The paper explicitly states the method is orthogonal to causal AR approaches (Section 5, Appendix E) but provides no empirical combination. A natural experiment is to take the fully trained decoupled model (with both FM and DM heads), add a causal attention mask, and fine-tune or distill it into a causal AR sampler that generates frame-by-frame. The distribution matching head's few-step capability would be particularly valuable here: an AR model where each autoregressive step requires only 4–8 DM head evaluations instead of 50+ diffusion steps would make real-time or streaming video generation practical. The hypothesis is that the shared encoder's long-range representations (learned from bidirectional SFT on real long videos) provide a strong initialization that reduces AR drift compared to training a causal model from scratch. Metrics would include both quality (VBench, Gemini) and speed (NFE per AR step, wall-clock time per second of generated video) compared to CausVid and Self-Forcing, which represent the current state of causal AR video diffusion. The paper's Gemini score of 74.3 for the bidirectional model vs. 54.8 for CausVid suggests substantial headroom that a bidirectional-to-causal distillation could capture.

Practical Applications and Downstream Use Cases

Data-efficient fine-tuning of large video models for long-form content creation. The paper's central finding — that a frozen short-video teacher can supervise local realism without requiring additional short-video training data — has immediate implications for studios and content platforms fine-tuning foundation video models on proprietary long-form content. Instead of collecting massive paired short-and-long video datasets (which is what joint training on mixed-length data effectively requires), a studio need only curate its long-form content (feature films, continuous-shot documentaries, multi-minute gameplay recordings) and use its existing short-video foundation model as the teacher. The training pipeline becomes: take a pretrained short-video model (acting as student backbone and frozen teacher simultaneously), add the dual-head architecture, and fine-tune on the studio's long-form data with the SFT + DMD joint objective. The paper's ablation results provide concrete guidance: removing the SFT anchor degrades Gemini consistency from 74.3 to 56.8 (Table 2), so the studio's long-form data must include genuinely long continuous shots — edited sequences with cuts will not provide the temporal continuity the SFT head needs. The +11.5 point Gemini improvement over MixSFT (Table 1) suggests that even a modest long-video dataset (~100k videos, per Appendix B) can yield substantial coherence gains when combined with teacher matching, compared to training on the same data with standard SFT.

Few-step inference for real-time or interactive long-video applications. The DM head's few-step sampling capability — claimed in Section 3.7 but not benchmarked — represents a potential deployment breakthrough for applications requiring low-latency long-video generation. In an interactive world model for game engines or embodied agent training, each agent action requires generating the next video segment in real time (ideally at interactive frame rates). Standard flow-matching models require 50+ NFE per generation, making real-time operation infeasible. If the DM head achieves 4–8 NFE (consistent with DMD literature), this represents a ~6–12× speedup that could bring minute-scale video generation into the interactive regime. The key deployment architecture would be: pre-generate a long initial video segment (using the full model), then for each new agent action, use the DM head for fast autoregressive extension of the video conditioned on the action and previous frames. The paper's bidirectional training means the model can attend to the full history when generating each extension, avoiding the error accumulation that plagues causal AR methods. The competitive dynamic degree (0.423, Table 1) and Gemini consistency (74.3) suggest the method would maintain motion quality and semantic coherence through interactive rollouts, though this specific use case would need dedicated evaluation.

Cost-efficient batch video generation for synthetic data pipelines. Organizations generating synthetic video data for downstream tasks (autonomous vehicle training, robotics simulation, video understanding model training) face a compute allocation problem: should they invest in longer training runs on larger models, or in smarter inference strategies on existing models? The paper's finding that the proposed method improves aesthetic quality by 0.054 and imaging quality by 0.047 over MixSFT (Table 1) — at the same 1.3B parameter scale — suggests that improving how you train can yield quality gains comparable to scaling model size, but at the inference cost of a 1.3B rather than a 14B model. The Wan 14B qualitative results (supplemental website, not quantified) would be critical to substantiate this, but the principle transfers: for synthetic data generation where quality matters more than diversity (mode-seeking is beneficial, not harmful), the decoupled training approach may be more cost-effective than scaling parameters. The practical recipe is: use the DM head's few-step sampling for generation speed, accept the potential diversity reduction from mode-seeking alignment (which is tolerable for synthetic data where coverage of edge cases matters less than per-sample realism), and benefit from the long-range coherence that the SFT anchor provides for temporally extended training sequences.

When to Prefer This Method

The paper does not articulate a clear decision rule positioning the proposed method against specific named alternatives for practitioners choosing between approaches. The comparisons in Section 4 are against baselines that the paper argues are suboptimal (SFT-only, teacher-only AR, sink-based extrapolation), and the ablation validates that the full method outperforms its own ablated variants — but the paper never says "use our method instead of X when condition Y holds." The framing is that the method closes the fidelity-horizon gap, implying it is preferable in any setting where both local quality and long-range coherence matter, but no explicit tradeoff conditions (e.g., based on available data quality, teacher quality, compute budget, or target horizon) are provided. I therefore omit this section rather than constructing a generic decision matrix the paper does not support.