Helios: Real Real-Time Long Video Generation Model

🎯 Pitch

A 14B video model hits 19.5 FPS on a single GPU by deliberately training on corrupted frames—a strategy that eliminates the drifting plaguing all other long-form generators, yet costs less to run than most 1.3B models.

1. Executive Summary

This paper introduces Helios, a 14B-parameter autoregressive diffusion model for real-time long video generation that achieves 19.5 FPS on a single NVIDIA H100 GPU while matching the quality of a strong baseline. The system is evaluated on HeliosBench, a newly constructed benchmark of 240 prompts spanning four duration regimes (81 to 1440 frames), using the Wan-2.1-T2V-14B model as the initialization backbone. Helios contributes three named mechanisms: Unified History Injection (formulating long-video generation as video continuation with Guidance Attention and Representation Control, rather than causal masking), Easy Anti-Drifting (Relative RoPE, First-Frame Anchor, and Frame-Aware Corrupt that explicitly simulate drifting during training, eliminating the need for self-forcing or error-banks), and Deep Compression Flow (Multi-Term Memory Patchification and Pyramid Unified Predictor Corrector that compress historical and noisy contexts, plus Adversarial Hierarchical Distillation that reduces sampling steps from 50 to 3). The distilled model delivers a 128× speedup over the 14B Wan baseline and a 4× efficiency advantage over same-sized accelerated models (2–3× faster than FastVideo and TurboDiffusion), while outperforming all existing distilled long-video methods on both quality and anti-drifting metrics, establishing that real-time minute-scale generation with a large model is achievable without standard acceleration techniques—but only when the model is trained with explicit corruption to simulate the inference-time error accumulation that bidirectional pretrained models otherwise cannot tolerate.

2. Context and Motivation

The Core Problem: Real-Time Long Video Generation at Scale Remains Unsolved

The fundamental question this paper tackles is deceptively ambitious: can a large (14B-parameter) video generation model produce temporally coherent, high-quality videos of arbitrary length at interactive frame rates on a single GPU? The prevailing answer in the field, prior to this work, was a qualified "no." Mainstream video generation models—often built on Diffusion Transformers (DiTs)—have improved dramatically in quality over the past year, but they remain constrained along two axes that make real-time, long-duration generation impractical for deployment.

This gap matters for several reasons the authors identify throughout Section 1 and the Related Work (Section 2):

Interactive applications require real-time throughput. Game engines that synthesize visual environments on-the-fly, creative tools where artists iteratively refine prompts, and conversational AI agents that generate visual responses all demand sub-second per-frame latency. A model that takes 50 minutes to generate a 5-second clip (as the authors cite for Wan2.1 14B on an A100) is useless for these use cases, regardless of its visual fidelity.
Prolonged experiences demand minute-scale coherence. Many real-world applications—virtual cinematography, continuous world simulation for embodied AI, background generation for streaming—require videos of a minute or more. Models that degrade after 5–10 seconds due to accumulated error (drifting) cannot serve these needs, forcing practitioners into awkward workarounds like stitching short clips with jarring transitions.
Large models capture complex motion and fine details that small models miss. The authors explicitly note that existing real-time systems are "typically built on relatively small backbones (e.g., Wan2.1 1.3B)" whose "limited capacity... makes it difficult to represent complex motion and often leads to blurred high-frequency details." There is a genuine quality ceiling imposed by parameter count, and simply distilling a small model faster does not address the fundamental representational bottleneck.

The problem, then, is not just "make video generation faster" or "make videos longer." It is the simultaneous satisfaction of three constraints that have historically been in tension: (1) large model capacity (14B parameters for rich motion and texture), (2) minute-scale temporal coherence without drifting, and (3) real-time throughput (≥15–20 FPS) on a single commodity GPU. No prior system achieves all three.

Prior Approaches and Where They Fall Short

The paper identifies several families of prior work, each of which addresses one or two of the three constraints but fails on the third. The authors' critique is specific and technical, so it is worth walking through each category carefully.

Short-Video Bidirectional Models: High Quality, No Real-Time, No Long Generation

The dominant paradigm in video generation as of early 2025 is the Diffusion Transformer trained with bidirectional attention over a fixed-length clip. Representative models cited include Wan2.1 14B, HV Video 13B, CogVideoX 5B, Mochi-1 10B, and Kandinsky 5 Pro 19B. These models produce high-quality output (Table 3 shows Wan2.1 14B achieving a Semantic score of 6 and Naturalness of 5), but they suffer from two fatal limitations for the target use case:

They are extraordinarily slow. The paper reports that Wan2.1 14B achieves 0.33 FPS on an H100—meaning a 5-second, 81-frame clip takes approximately 4 minutes to generate. HV Video 13B is even slower at 0.36 FPS. This is 50–60× slower than real-time, making interactive use impossible.
They cannot generate beyond their training horizon. These models are trained on fixed-length clips (typically 5–10 seconds) with absolute positional encodings. They have no mechanism for autoregressive extension—they produce one clip and stop. The paper mentions that simply "changing the video length exposes the model to unseen temporal positions and can substantially degrade quality" (Section 3.2.1), a form of distribution shift that bidirectional models cannot handle at inference time.

Acceleration techniques exist for these models. FastVideo and TurboDiffusion apply distillation and quantization to squeeze 5–10 FPS out of Wan2.1 14B, but this comes at the cost of quality degradation (Table 3: FastVideo achieves only 5.25 Total vs. 6.35 for the Wan2.2 14B baseline) and, critically, does not address the duration limitation—these models still produce only short clips.

Autoregressive Long-Video Models: Longer Duration, But Small Scale and Fragile

A separate line of work, exemplified by CausVid (Tian et al.), Self-Forcing (Chen et al.), and their many derivatives (Rolling Forcing, LongLive, Infinite Forcing, Reward Forcing, Causal Forcing, Dummy Forcing), tackles the duration problem explicitly. The shared strategy is causal masking: modify the attention mechanism of a pretrained bidirectional DiT so that each frame can only attend to past frames, converting the model into an autoregressive generator that can, in principle, produce arbitrarily many frames by iteratively conditioning on its own outputs.

This approach works to a degree. Table 4 shows that these 1.3B models achieve throughput of 18–24 FPS and produce videos of 240+ frames with non-trivial quality (Self-Forcing: 5.00 Total at long durations; Reward Forcing: 6.88). However, the paper identifies several fundamental weaknesses:

First, the model scale is severely constrained. All of these systems use Wan2.1 1.3B as the backbone, which the authors explicitly argue is insufficient: "The limited capacity of these models makes it difficult to represent complex motion and often leads to blurred high-frequency details." There is a reason for this—the training procedures required for causal-masking-based autoregressive generation, particularly self-forcing rollouts, are computationally prohibitive at larger scales. The paper explains: "Self-Forcing explicitly integrates the inference procedure of an autoregressive model into the training process: when generating the current section, previously generated sections are used as conditions." This "train-as-infer" strategy requires generating multi-section rollouts during training. When only 5 sections are rolled out, "the model frequently exhibits severe exposure bias during inference once the generated sequence exceeds this length." To mitigate this, subsequent work adopted "long self-rollout" where "a large number of sections—corresponding to video durations of tens of seconds or even several minutes—are generated during training to enhance long-term stability." This is what "restricts existing methods to models with approximately 1.3B parameters"—the computational cost of long rollouts at 14B scale would be prohibitive.

Second, causal masking fundamentally changes the inference regime and may limit quality. The paper argues (Section 3.1.1) that "the inference procedure deviates substantially from the pre-trained model, limiting the achievable performance." Bidirectional attention allows each frame to integrate information from the entire clip, enabling global coherence. Causal masking restricts attention to past frames only, which can cause each section to "tend to generate an independent new scene" (as observed in the Guidance Attention ablation, Section 5.4.1, Figure 16). The paper explicitly attributes this to causal masking "limiting cross-section interactions, undermining temporal coherence across sections."

Third, these methods still exhibit drifting at scale. Even the 14B Krea model, which follows the same paradigm, "suffers from severe drifting." The authors argue that robustness to drifting in causal-masking approaches is "tightly coupled to the rollout length used during training: when training is restricted to 5-second clips, severe drifting often emerges beyond the 5-second horizon at inference." This creates an expensive tradeoff: longer rollouts during training improve stability but restrict model scale. The paper's key insight is that this tradeoff is an artifact of the causal masking approach and can be circumvented entirely by a different architectural choice (video continuation with bidirectional attention over history) plus explicit corruption during training.

Krea-RealTime-14B: Larger Scale, But Still Slow and Drifting

The paper specifically calls out Krea-RealTime-14B as the only prior attempt to scale real-time long-video generation to 14B parameters. It "largely follows the same paradigm" (causal masking, Self-Forcing rollouts, DMD distillation) and achieves only 6.7 FPS on an H100—far below the 19.5 FPS Helios achieves. Moreover, "the results suffer from severe drifting, which remains problematic for real-time interactive generation." Krea represents the state of the art prior to Helios, and it demonstrates that simply scaling up the existing paradigm is insufficient: the underlying architectural choices impose ceilings on both speed and quality that cannot be overcome by more compute alone.

Long-Video Methods Without Causal Masking: Slow and Training-Heavy

A smaller set of approaches, including Diffusion Forcing, Rolling Diffusion, and LongCat-Video, extend bidirectional models to longer durations without causal masking by injecting frame-wise noise or using autoregressive diffusion. The paper acknowledges these as conceptually related to Helios's approach but notes that they "often exhibit pronounced drifting beyond their training horizon or rely on costly long-video fine-tuning, which limits their practicality." LongCat-Video (13.6B) achieves reasonable quality on long videos (6.54 Total in Table 4) but runs at only 0.33 FPS—two orders of magnitude slower than real-time. The computational cost of these methods makes them fundamentally incompatible with the real-time requirement.

Standard Anti-Drifting Strategies: Expensive and Insufficient

The paper identifies several techniques commonly used to combat drifting in autoregressive generation, all of which it explicitly avoids:

Self-Forcing (train-as-infer rollouts): As discussed, this substantially increases training cost and "motivates step distillation" because the training procedure becomes so expensive. The paper argues that robustness is "tightly coupled to the rollout length," creating a fragility that Helios's explicit corruption strategy avoids.
Error-banks: Store past generation errors to condition future generation, as explored in some recent work. The paper does not provide extensive detail on why error-banks are insufficient, but the implication is that they are a reactive mechanism that patches symptoms rather than addressing root causes, and they add architectural complexity.
Keyframe sampling: Periodically resample keyframes to reset accumulated error. This can introduce temporal discontinuities at resampling boundaries and requires careful scheduling that may not generalize across content types.
Inverted sampling (FramePack): Reverse the inference direction to reduce error propagation. The paper notes this approach exists but does not engage with it in depth, treating it as one of several heuristics that Helios renders unnecessary.

Step Distillation: Fragile and Constraining

All existing real-time long-video systems rely on step distillation (typically DMD, reducing sampling steps from 50 to 4) to achieve usable throughput. The paper identifies two problems with this approach as it is conventionally applied:

"Distilled models hinder further development within the community." Because the distilled model is a fundamentally different beast from the original diffusion model—using $x_0$ -prediction instead of $v$ -prediction, requiring specialized training procedures—improvements to the base model architecture or training cannot be easily transferred to the distilled version. Each base model advance requires re-distillation, slowing the research cycle.
Standard DMD assumes a different sampling procedure than what Helios introduces. The paper notes that "Helios changes the sampling procedure, so the standard pipeline is not directly applicable." The multi-scale Pyramid Unified Predictor Corrector and the staged generation process require non-trivial modifications to the distillation framework, which the paper addresses with Adversarial Hierarchical Distillation.

Where This Paper Positions Itself

Helios's central intellectual move is to reject the dominant causal-masking paradigm for autoregressive generation and instead formulate long-video generation as video continuation with bidirectional attention over the full (history + noisy) context. This is not a minor architectural tweak—it fundamentally changes the nature of the problem and enables solutions to all three constraints simultaneously.

The paper's framing (Section 1, contributions list) is deliberately provocative: it claims to achieve real-time, minute-scale, high-quality generation without any of the techniques the community considers standard for acceleration or anti-drifting: no KV-cache, no sparse/linear attention, no quantization, no self-forcing, no error-banks, no keyframe sampling. This is a rhetorical strategy that highlights the novelty of the approach: rather than incrementally improving existing methods, Helios restructures the problem so that these techniques become unnecessary.

The core insight is that drifting—the central obstacle to long-video generation—is not an inevitable consequence of autoregressive error accumulation but rather a specific failure mode of the training paradigm. If the model is trained on clean videos but tested on its own imperfect outputs, small errors compound. The solution is not to avoid imperfect inputs (which is impossible in autoregressive generation) but to train the model to be robust to them. This is the philosophy behind Easy Anti-Drifting: explicitly simulate the types of corruption that occur during inference (position shift via Relative RoPE, color shift via First-Frame Anchor, restoration shift via Frame-Aware Corrupt) and train the model to produce clean continuations from corrupted history. This approach is computationally cheap—it adds no inference overhead and minimal training overhead—compared to self-forcing rollouts, which scale quadratically with rollout length.

For speed, the paper similarly rejects the standard acceleration toolkit in favor of a different decomposition of the problem. Rather than making the existing architecture faster (via KV-cache, sparse attention, etc.), Helios reduces the number of tokens the architecture needs to process in the first place. Multi-Term Memory Patchification exploits the intuition that distant history requires less spatiotemporal resolution than recent history, compressing the historical context by 8× without losing information critical for generation. Pyramid Unified Predictor Corrector exploits the observation that early denoising steps at low resolution are sufficient for global structure, reducing the noisy-context token count by 2.29×. These are conceptual rather than engineering optimizations: they change what information the model processes, not how efficiently it processes it.

Finally, the paper positions its three-stage training pipeline as a deliberate strategy for managing the complexity of building a 14B autoregressive video model. Stage 1 (Base) converts the bidirectional pretrained model into an autoregressive video continuation model. Stage 2 (Mid) introduces token compression to improve throughput while accepting a small quality degradation. Stage 3 (Distilled) uses the Stage 1 model as teacher to recover quality while reducing sampling steps from 50 to 3, achieving the final 19.5 FPS throughput. This progressive approach means that each stage builds on a functioning predecessor rather than attempting to solve all problems simultaneously, which would make debugging and hyperparameter tuning intractable at this scale.

The construction of HeliosBench further signals the paper's positioning: by releasing a standardized benchmark with 240 prompts across four duration regimes, the authors aim to establish infrastructure for a research direction they believe will grow rapidly. The explicit comparison to prior work across throughput, quality, and anti-drifting metrics (Tables 3, 4; Figures 1, 2) is designed to show that Helios is not merely competitive but defines a new Pareto frontier in the speed-quality-duration trade space.

3. Technical Approach

3.1 Reader Orientation

Helios is a video generation system that takes a text prompt (and optionally an image or video) and produces videos of arbitrary length—potentially minutes or more—by generating short chunks one after another, each conditioned on the previously generated frames. The core problem the system solves is the simultaneous achievement of three goals that have historically been in tension: (1) using a large 14B-parameter model to capture complex motion and fine details, (2) maintaining temporal coherence over minute-scale durations without the accumulated errors known as "drifting," and (3) running fast enough for real-time interaction—specifically at 19.5 frames per second on a single NVIDIA H100 GPU. The shape of the solution is a three-stage training pipeline that progressively converts a pretrained bidirectional video diffusion model into an autoregressive video continuation model, compresses its token budget to reduce computation, and finally distills it to a few-step generator—all while explicitly training against the specific corruption patterns that cause autoregressive models to drift.

3.2 Big-Picture Architecture

Helios has five major components arranged in a pipeline:

Representation Control — a unified input interface that accepts text, an image, a video clip, or nothing (zeros) as historical context, automatically switching between text-to-video (T2V), image-to-video (I2V), and video-to-video (V2V) modes based on the input pattern.
Guidance Attention — a modified self-attention and cross-attention block within each DiT layer that treats historical context (clean, already-generated frames) differently from noisy context (frames currently being generated). The historical keys are modulated by learned per-head amplification tokens that selectively amplify or suppress historical information, and cross-attention injects text semantics only into the noisy context, avoiding redundant re-injection into history.
Easy Anti-Drifting — a set of three training-time mechanisms (Relative RoPE, First-Frame Anchor, Frame-Aware Corrupt) that explicitly simulate the distribution shifts that cause drifting at inference time, so the model learns to produce clean continuations from corrupted history rather than degrading when conditioned on its own imperfect outputs.
Deep Compression Flow (Token View) — two techniques that drastically reduce the number of visual tokens processed by the DiT: Multi-Term Memory Patchification compresses historical context by 8× using hierarchical spatiotemporal kernels, and Pyramid Unified Predictor Corrector redistributes denoising across multiple resolutions, reducing noisy-context tokens by 2.29×.
Adversarial Hierarchical Distillation (Step View) — a DMD-based distillation framework adapted for multi-scale generation that reduces sampling steps from 50 to 3, eliminates classifier-free guidance, and incorporates an adversarial GAN objective to surpass the teacher's quality ceiling.

Information flows as follows: a user provides a text prompt and optionally an image/video → the Representation Control module formats the historical context (zeros for T2V, last frame for I2V, full clip for V2V) → Multi-Term Memory Patchification compresses the history into long/mid/short-term tokens → the Pyramid Unified Predictor Corrector initializes low-resolution noise and denoises through coarse-to-fine stages → at each DiT layer, Guidance Attention processes historical and noisy contexts separately, with text injected into the noisy branch → the VAE decoder converts latents to RGB frames → generated frames are appended to history for the next autoregressive step → if Interactive Interpolation is active, the text embedding is gradually transitioned from the current prompt to a new user-specified prompt across multiple generation steps.

3.3 Roadmap for the Deep Dive

First, the Unified History Injection mechanism (Section 3.1), because it defines the fundamental autoregressive paradigm—video continuation with bidirectional attention—that all downstream components depend on. Understanding why the model avoids causal masking and how it handles T2V/I2V/V2V within a single architecture is prerequisite for everything else.
Second, the Easy Anti-Drifting strategies (Section 3.2), because they address the central failure mode that would otherwise make autoregressive generation useless at scale. These techniques operate at the training-data and positional-encoding level, so they interact with Unified History Injection at a fundamental level.
Third, Deep Compression Flow from the token perspective (Section 3.3), covering Multi-Term Memory Patchification and Pyramid Unified Predictor Corrector. These explain how the model achieves computational efficiency despite processing long histories, and they introduce the multi-scale generation paradigm that the distillation step depends on.
Fourth, Deep Compression Flow from the step perspective (Section 3.4), covering Adversarial Hierarchical Distillation. This is the most architecturally complex component, and it builds directly on the multi-scale framework introduced in Section 3.3 so the staging cannot be reordered.
Fifth, the inference-time techniques (Section 3.5), which are training-free and sit on top of the trained model to provide additional robustness (Adaptive Sampling) and interactivity (Interactive Interpolation).

3.4 Detailed Technical Breakdown

This is primarily an architectural and training-methodology paper whose core idea is that a 14B video diffusion model can achieve real-time, minute-scale generation if three conditions are met: (1) autoregressive generation is formulated as video continuation with bidirectional attention rather than causal masking, (2) drifting is prevented by explicitly simulating inference-time corruption during training rather than relying on expensive train-as-infer rollouts, and (3) token counts are compressed by exploiting temporal locality (coarse history, fine recent context) and spatial redundancy (low-resolution early denoising).

3.4.1 Unified History Injection: Autoregressive Generation Without Causal Masking

The core architectural problem Helios solves is: how do you turn a pretrained bidirectional DiT—which can only generate fixed-length clips—into a model that can generate arbitrarily long videos? The dominant community solution has been causal masking, but Helios argues this is fundamentally limiting and proposes an alternative.

The Problem with Causal Masking

A standard DiT for video generation processes a fixed-length spatiotemporal input—say, 81 frames of dimensions $C \times 81 \times H \times W$ —with full bidirectional attention. Every frame can attend to every other frame. To make this model autoregressive (generate frame 82, then 83, then 84...), prior work applied causal masking to the attention matrix, so each frame attends only to past frames. The paper identifies three specific failures of this approach:

Training-inference gap. The pretrained model learned to generate coherent videos under bidirectional attention. Forcing it into a causal regime changes the attention pattern the model was optimized for, and the model must learn to compensate for the lost information. This is what the paper means by "the inference procedure deviates substantially from the pre-trained model, limiting the achievable performance" (Section 3.1.1).
Scale constraint from self-forcing. Closing the training-inference gap requires train-as-infer rollouts (Self-Forcing), where the model generates multi-section sequences during training. To achieve stability beyond the training horizon, these rollouts must be long—"tens of seconds or even several minutes"—which becomes computationally prohibitive above ~1.3B parameters (Section 3.4.2).
Loss of cross-section coherence. Causal masking prevents the current section from attending to future sections (by definition), but more subtly, it also prevents sections from establishing global semantic coherence. The ablation in Section 5.4.1 (Figure 16) shows that when causal masking is added to Helios's Guidance Attention, "each generated section appears independent"—the model loses the ability to maintain consistent scene identity across sections because it cannot integrate global context.

Representation Control: Video Continuation with Masked Inputs

Helios instead formulates long-video generation as video continuation. At each autoregressive step, the model receives two concatenated tensors:

Historical context $X_{\text{Hist}} \in \mathbb{R}^{B \times C \times T_{\text{Hist}} \times H \times W}$ : A window of previously generated, clean frames that serve as conditioning. $T_{\text{Hist}}$ is fixed during both training and inference, and the paper explicitly states that $T_{\text{Hist}} \gg T_{\text{Noisy}}$ .
Noisy context $X_{\text{Noisy}} \in \mathbb{R}^{B \times C \times T_{\text{Noisy}} \times H \times W}$ : The frames currently being generated, initialized from Gaussian noise and progressively denoised over multiple sampling steps.

The model's job is to denoise $X_{\text{Noisy}}$ conditioned on $X_{\text{Hist}}$ to produce a clean continuation. After denoising, the newly generated clean frames are appended to the history for the next autoregressive step. Because $X_{\text{Hist}}$ and $X_{\text{Noisy}}$ have fixed sizes, the token count per step is constant regardless of how long the video has been going—a critical property for maintaining constant throughput.

Task switching via input representation. The key architectural elegance of Representation Control is that the same model handles T2V, I2V, and V2V without any mode-switching logic. The authors define three input patterns:

T2V: $X_{\text{Hist}}$ is all zeros (padded). The model has no visual history to condition on, so it generates from text alone.
I2V: Only the last frame of $X_{\text{Hist}}$ is nonzero—the input image. The model generates a video that extends from that single frame.
V2V: $X_{\text{Hist}}$ contains a full video clip. The model continues the video coherently.

During training, the paper states that it "randomly zero out a certain proportion of the historical context to simulate T2V, I2V, and V2V during inference" (Section 3.3.1). This means a single training batch contains a mixture of modes, and the model learns to treat the presence or absence of historical frames as a signal for what task to perform.

Guidance Attention: Differentiated Treatment of History and Noise

The concatenation of $X_{\text{Hist}}$ and $X_{\text{Noisy}}$ is processed jointly through the DiT, but the paper argues these two contexts "exhibit different statistics and should therefore be treated differently" (Section 3.1.2). The historical context is clean, already aligned with the text prompt, and should remain unchanged—it serves as a fixed conditioning signal. The noisy context is being actively generated and should be the target of denoising and text-driven modification. Standard self-attention would blend them indiscriminately, which the paper shows leads to "excessive semantic accumulation over time (e.g., a progressively enlarged bird crest)" in the ablation study (Section 5.4.1, Figure 16).

To enforce this separation, Helios makes two modifications within each DiT block:

Historical timestep fixing. The timestep embedding for $X_{\text{Hist}}$ is fixed to $t = 0$ throughout the denoising process, indicating that these frames are noise-free. Only the noisy context receives the current diffusion timestep. This tells the model at the architectural level: "do not denoise these frames; they are already clean."

Amplified key modulation in self-attention. In the self-attention layer, the model computes separate query, key, and value tensors for the noisy and historical contexts:

For noisy context: $Q_{\text{Noisy}}$ , $K_{\text{Noisy}}$ , $V_{\text{Noisy}}$
For historical context: $Q_{\text{Hist}}$ , $K_{\text{Hist}}$ , $V_{\text{Hist}}$

The paper then introduces head-wise amplification tokens $amp$ , which are learned parameters that modulate the historical keys before the attention computation:

$X_{\text{Self}} = \text{Attention}([Q_{\text{Noisy}}, Q_{\text{Hist}}], [K_{\text{Noisy}}, K_{\text{Hist}} \cdot amp], [V_{\text{Noisy}}, V_{\text{Hist}}])$

where $[\cdot, \cdot]$ denotes concatenation along the sequence dimension, and $\cdot$ denotes element-wise multiplication. The amplification tokens are per-head, meaning different attention heads can learn to amplify or attenuate different aspects of the historical information.

What this equation represents operationally: The attention mechanism computes attention weights between all query tokens (from both noisy and historical contexts) and all key tokens (from both contexts, but with the historical keys scaled by the learned $amp$ parameters). The output is a weighted sum of the value tensors from both contexts. The $amp$ parameters act as a learnable gate: if a head's $amp$ value is close to zero, that head effectively ignores the historical context. If it is large, that head amplifies historical influence. By learning these per-head weights during training, the model can selectively attend to historical information where it helps (e.g., maintaining subject identity, color palette, scene layout) while suppressing it where it might interfere (e.g., copying static elements that should be in motion).

Why this form over alternatives? A simpler alternative would be to concatenate the contexts without modulation and hope the model learns to use them appropriately. The ablation shows this fails: without Guidance Attention, the model "progressively accumulates semantic content over time." Another alternative would be causal masking, but the ablation shows that this "substantially reduces representational capacity and makes optimization harder" because it "limits cross-section interactions, undermining temporal coherence across sections; as a result, each section tends to generate an independent new scene" (Section 5.4.1, Table 5). The amplification-based approach preserves bidirectional attention while giving the model explicit control over how much history influences each attention head.

Text injection via cross-attention (noisy-only). In the cross-attention layer, the paper observes that "since $X_{\text{Hist}}$ has already incorporated the semantics from previous steps, re-injecting the same semantics is redundant." Therefore, cross-attention is applied only to the noisy context:

$X_{\text{Cross}} = \text{Attention}(Q_{\text{Noisy}}, K_{\text{Text}}, V_{\text{Text}})$

where $K_{\text{Text}}$ and $V_{\text{Text}}$ are the key and value tensors from the text encoder. The historical context does not participate in cross-attention, avoiding redundant semantic injection that could cause the model to over-express certain text features over time.

What this means computationally: Each DiT block has two attention operations. First, self-attention over the concatenated noisy and historical tokens (with modulated historical keys). Second, cross-attention where only the noisy tokens attend to the text tokens. The output of both is combined (presumably through residual connections and feed-forward layers, following standard DiT architecture, though the paper does not detail the exact combination).

3.4.2 Easy Anti-Drifting: Training Against Inference-Time Corruption

The second major technical contribution is a set of training strategies that prevent the quality degradation ("drifting") that occurs when an autoregressive model conditions on its own imperfect outputs. The paper identifies three distinct failure modes and proposes targeted interventions for each.

Failure Mode 1: Position Shift (Absolute Positional Encoding Out-of-Distribution)

The root cause: standard DiT training uses absolute Rotary Position Embeddings (RoPE) where each temporal position has a unique encoding. During training on short clips (e.g., 5 seconds, 81 frames), the model only sees temporal indices 0–80. At inference time, when generating a video of 1440 frames, the model encounters indices 81, 82, ..., 1439—positions it has never seen during training. This out-of-distribution shift causes quality degradation that worsens as the video length increases. The paper also identifies a secondary pathology: "absolute temporal indices may cause the generation to repeatedly snap back to early positions, leading to abrupt scene resets and cyclic patterns, which we refer to as repetitive motion" (Section 3.2.1). This occurs because RoPE is periodic, and if multi-head attention with different frequency bases interacts with this periodicity, certain temporal positions can "alias" to perceptual similarity with earlier positions.

Relative RoPE: the fix. Regardless of the target video length, the temporal indices assigned to $X_{\text{Hist}}$ are always constrained to the range $0:T_{\text{Hist}}$ , and the indices assigned to $X_{\text{Noisy}}$ are always $T_{\text{Hist}}:T_{\text{Hist}} + T_{\text{Noisy}}$ . The model never sees temporal indices outside these fixed ranges during either training or inference. When generating the next chunk, the temporal indices are re-anchored to the same relative range—the historical context is always 0 through $T_{\text{Hist}}$ , and the noisy context is always $T_{\text{Hist}}$ through $T_{\text{Hist}} + T_{\text{Noisy}}$ . This "relative indexing" means the model's positional encoding is invariant to absolute video length: it always sees the same range of indices, and the "distance" between any historical frame and any noisy frame is always computed relative to the chunk boundary, not the video start.

Why this helps beyond position shift: The paper claims that Relative RoPE "alleviates the interaction between RoPE periodicity and multi-head attention, thereby reducing repetitive motion at its source." Because the model always sees the same relative index range, the periodic properties of RoPE are consistently applied, and there is no mechanism for different absolute positions to accidentally produce similar attention patterns due to aliasing.

Failure Mode 2: Color Shift (Cumulative Distribution Drift in Color Space)

The paper characterizes this phenomenon quantitatively by tracking "saturation, aesthetic scores, and RGB statistics (mean and variance) over time" for normal versus drifting videos (Figure 6). Key empirical observation: "Normal videos exhibit relatively stable statistics, whereas drifting videos initially follow a similar trajectory but undergo a sharp shift after a certain point and remain unstable thereafter. Notably, drifting rarely occurs at the beginning of generation" (Section 3.2.2). This suggests that the first generated frame(s) are reliable, and the drift is a cumulative process where later frames progressively deviate from the initial color distribution.

First-Frame Anchor: the fix. During both training and inference, the model always retains the very first frame of the entire video in the historical context $X_{\text{Hist}}$ . This frame serves as a "global visual anchor" that the model can attend to when generating any subsequent frame. Because the first frame is always clean (it was generated at the very beginning, before any error accumulation could occur, or it is a user-provided image in I2V mode), it provides a stable reference for color distribution, scene layout, and subject identity.

Why this works: The key insight is that color shift is a distribution-level phenomenon—it is not that any individual frame is "wrong," but that the cumulative statistics drift away from the initial distribution. By forcing the model to attend to the first frame (which anchors the original distribution) every time it generates new content, the model has a mechanism to "pull back" its output distribution toward the reference. The ablation (Section 5.4.2, Figure 17) confirms this is critical: removing the First-Frame Anchor causes "noticeable degradation as early as frame 720, with errors compounding over longer sequences" and "the subject gradually deviates from the identity established in the first frame, causing cumulative identity drifting."

Failure Mode 3: Restoration Shift (Error Accumulation from Conditioning on Imperfect Outputs)

This is the most fundamental form of drifting: the model is trained on clean videos, but at inference time it conditions on its own (imperfect) previously generated frames as history. Small errors in these frames—blur, noise, slight color inaccuracies, minor geometric distortions—get compounded because the model was never trained to handle noisy inputs as conditioning. The paper describes this as "image-restoration artifacts, such as blur and noise," and notes that it "arises because the model is trained on clean videos but, at inference time, conditions on its own imperfect outputs as history; consequently, small errors can accumulate and amplify over time" (Section 3.2.3).

Frame-Aware Corrupt: the fix. During training, each frame in the historical context is independently perturbed with one of four operations, chosen randomly per frame:

Exposure adjustment (probability $p_c$ ): The frame's exposure is adjusted by a magnitude uniformly sampled from $[a_{\min}, a_{\max}]$ . In the Stage 3 training configuration (Table 2), $a_{\min} = 0.3$ and $a_{\max} = 1.7$ , meaning the exposure can range from severely underexposed (0.3×) to significantly overexposed (1.7×).
Noise injection (probability $p_a$ ): Additive noise is applied with a level uniformly sampled from $[b_{\min}, b_{\max}]$ . In Stage 1-post (Table 1), $b_{\min} = 0$ and $b_{\max} = 0.33$ .
Downsample-upsample (probability $p_b$ ): The frame is spatially downsampled and then upsampled back to the original resolution, using a downsampling factor uniformly sampled from $[c_{\min}, c_{\max}]$ . In Stage 1-post, $c_{\min} = 0$ and $c_{\max} = 0.1$ , corresponding to mild blur.
Keep clean (probability $p_d$ ): The frame is left unperturbed.

These probabilities sum to 1 ( $p_a + p_b + p_c + p_d = 1$ ). The paper emphasizes that "perturbations are sampled independently per frame, so a history of $T_{\text{Hist}}$ frames yields $T_{\text{Hist}}$ independent corruption decisions, which is crucial for long-video stability." In Stage 1-post (Table 1), the settings are $p_a = 0.0$ , $p_b = 0.8$ , $p_c = 0.1$ , $p_d = 0.1$ , meaning 80% of historical frames receive blur, 10% receive exposure shift, and 10% are clean. In Stage 3 (Table 2), the settings shift to $p_a = 0.4$ , $p_b = 0.4$ , $p_c = 0.0$ , $p_d = 0.2$ , introducing noise corruption that was absent in earlier stages.

Why this works, and why it is superior to Self-Forcing: Frame-Aware Corrupt is conceptually simple but represents a fundamentally different approach to anti-drifting than the community-standard Self-Forcing. Self-Forcing generates multi-section rollouts during training and uses the model's actual outputs (with whatever errors they contain) as conditioning for subsequent sections. This is expensive because generating those rollouts requires full forward passes through the model during training, and achieving stability at long durations requires long rollouts. Frame-Aware Corrupt instead simulates the types of errors that occur during autoregressive inference but does so offline—the corrupted frames are created by applying simple, cheap image-space transformations to ground-truth frames. The model learns to produce clean continuations from corrupted inputs without ever needing to run autoregressive rollouts during training. The ablation (Section 5.4.3, Figure 17) confirms this is essential: "removing it causes severe drifting even at 240 frames, leading to a sharp drop in Aesthetic, Semantic, and Naturalness."

3.4.3 Deep Compression Flow (Token View): Reducing the Number of Visual Tokens

The third major technical contribution addresses the computational bottleneck: a 14B DiT with standard attention over spatiotemporal tokens is far too expensive for real-time generation, even with optimized kernels. Helios reduces the token count in both the historical and noisy contexts by exploiting spatiotemporal redundancy.

Multi-Term Memory Patchification: Compressing Historical Context

The core observation (Section 3.3.1) is that "in autoregressive video generation, predicting future frames depends mostly on temporally nearby history for local motion and short-range continuity, whereas distant history primarily contributes coarse global context." This suggests a compression strategy: recent frames should be preserved at high spatiotemporal resolution (they inform fine motion and pixel-level continuity), while older frames can be aggressively compressed (they only need to convey scene identity, color palette, and coarse layout).

Helios implements this as a hierarchical context window that partitions $X_{\text{Hist}}$ into three segments:

Short-term: $T_1$ frames, receiving the mildest compression (kernel $(p_t^{(1)}, p_h^{(1)}, p_w^{(1)})$ ).
Mid-term: $T_2$ frames, receiving intermediate compression (kernel $(p_t^{(2)}, p_h^{(2)}, p_w^{(2)})$ ).
Long-term: $T_3$ frames, receiving the most aggressive compression (kernel $(p_t^{(3)}, p_h^{(3)}, p_w^{(3)})$ ).

The frame counts satisfy $0 < T_1 < T_2 < T_3$ , and the compression ratios satisfy $p_t^{(1)} < p_t^{(2)} < p_t^{(3)}$ , $p_h^{(1)} < p_h^{(2)} < p_h^{(3)}$ , and $p_w^{(1)} < p_w^{(2)} < p_w^{(3)}$ . The paper reports the specific configuration used in practice (Section 4.1): $(p_t^{(1)}, p_t^{(2)}, p_t^{(3)}) = (4, 2, 1)$ and $(p_h^{(1)}, p_h^{(2)}, p_h^{(3)}) = (8, 4, 2)$ and $(p_w^{(1)}, p_w^{(2)}, p_w^{(3)}) = (8, 4, 2)$ , with $(T_1, T_2, T_3) = (16, 2, 2)$ .

Token count calculation. After patchification, the number of tokens in each segment is:

$L_{\text{short}} = \frac{T_1 HW}{p_t^{(1)} p_h^{(1)} p_w^{(1)}}, \quad L_{\text{mid}} = \frac{T_2 HW}{p_t^{(2)} p_h^{(2)} p_w^{(2)}}, \quad L_{\text{long}} = \frac{T_3 HW}{p_t^{(3)} p_h^{(3)} p_w^{(3)}}$

where $H$ and $W$ are the spatial dimensions of the latent representation. The total token count for the historical context is:

$L_{\text{total}} = HW \left( \frac{T_1}{p_t^{(1)} p_h^{(1)} p_w^{(1)}} + \frac{T_2}{p_t^{(2)} p_h^{(2)} p_w^{(2)}} + \frac{T_3}{p_t^{(3)} p_h^{(3)} p_w^{(3)}} \right)$

What this equation represents operationally: For each segment, a 3D convolution with kernel size $(p_t, p_h, p_w)$ and stride equal to the kernel size is applied to the spatiotemporal volume. This is not learned convolution—it is a fixed patchification that aggregates spatiotemporal neighborhoods into single tokens by averaging (or some other simple operation; the paper does not specify the exact reduction function, but the term "patchification" implies either averaging or a learned linear projection, analogous to ViT patch embedding). The result is that the $T \times H \times W$ volume of latents is reduced to $\frac{T}{p_t} \times \frac{H}{p_h} \times \frac{W}{p_w}$ tokens.

Token reduction magnitude. With the reported settings, the paper states (Section 4.1) that the historical-context token count is reduced from $5HW$ to $\frac{5}{8}HW$ , an approximately $8\times$ reduction. Let us verify: without compression, a window of $T_1 + T_2 + T_3 = 16 + 2 + 2 = 20$ frames would yield $20HW$ tokens. With the compression ratios:

Short-term (16 frames): $16HW / (4 \cdot 8 \cdot 8) = 16HW / 256 = \frac{1}{16}HW$ tokens
Mid-term (2 frames): $2HW / (2 \cdot 4 \cdot 4) = 2HW / 32 = \frac{1}{16}HW$ tokens
Long-term (2 frames): $2HW / (1 \cdot 2 \cdot 2) = 2HW / 4 = \frac{1}{2}HW$ tokens

Total: $\frac{1}{16}HW + \frac{1}{16}HW + \frac{1}{2}HW = \frac{1}{8}HW + \frac{1}{2}HW = \frac{5}{8}HW$ , which matches the paper's claim. Compared to $20HW$ tokens without compression, this is a $20 / (5/8) = 32\times$ reduction. The discrepancy with the "8×" figure suggests the uncompressed window in the paper's comparison might not be 20 frames but some smaller baseline (e.g., 5 frames yielding $5HW$ tokens, compared to $\frac{5}{8}HW$ , giving $5 / (5/8) = 8\times$ ). The exact baseline is not specified with complete clarity, but the magnitude of compression is clearly significant.

Why this form over alternatives: A simpler compression strategy would be uniform downsampling—just reduce the spatial resolution of all historical frames equally. This would either discard detail needed for motion continuity (if aggressive) or retain excessive tokens (if conservative). The hierarchical approach allocates the token budget where it matters most (recent frames at high resolution) while still providing a long temporal context at coarse resolution. The paper also notes in the caption of Figure 7 that this design "keeps $L_{\text{total}}$ constant regardless of the target video length," which is essential for constant throughput during autoregressive generation—otherwise, the history token count would grow linearly with video duration, eventually making generation impossibly slow.

Pyramid Unified Predictor Corrector: Compressing Noisy Context via Multi-Scale Denoising

The second token-reduction strategy targets the noisy context $X_{\text{Noisy}}$ . The key observation is that "early sampling steps are dominated by strong noise and thus mainly determine global structure (e.g., layout and color), whereas later steps primarily refine fine-grained details (e.g., edges and textures)" (Section 3.3.2). This suggests that early denoising steps can operate at low spatial resolution without losing critical information—the model only needs to establish the coarse arrangement of objects and colors, and the fine details can be filled in later at full resolution.

Training: learning the velocity field across scales. Helios partitions the generative process into $K$ stages with increasing spatial resolutions, where stage $k$ operates at resolution $(h^k, w^k)$ . The paper sets $K = 3$ in practice. At each stage, the model learns a velocity field $u_\theta^k$ that transports the sample from the previous (lower-resolution) stage to the current stage.

The transport path between scales is defined as a linear interpolation:

$x_t^k = (1 - \lambda_t) x^k + \lambda_t \text{Up}(x^{k-1})$

where $x^k$ is the clean target at scale $k$ , $\text{Up}(x^{k-1})$ is the upsampled output from the previous scale, and $\lambda_t \in [0, 1]$ controls the noise level. At $\lambda_t = 0$ , $x_t^k = x^k$ (fully clean). At $\lambda_t = 1$ , $x_t^k = \text{Up}(x^{k-1})$ (fully noisy, equal to the upsampled previous-scale output).

The ground-truth velocity along this path is constant:

$v^k = x^k - \text{Up}(x^{k-1})$

What this velocity represents operationally: The difference between the clean high-resolution target $x^k$ and the upsampled low-resolution output $\text{Up}(x^{k-1})$ . It encodes the "missing detail" that stage $k$ must add on top of the upsampled coarse structure from stage $k-1$ . Learning to predict this velocity is equivalent to learning a residual: the model at stage $k$ learns to predict what needs to be added to the upsampled lower-resolution estimate to recover the full-resolution target.

The velocity-matching objective is:

$\mathcal{L} = \mathbb{E}_{k, \lambda_t, x_t^k, \text{Up}(x^{k-1}), y} \left[ \|u_\theta^k(x_t^k, y, \lambda_t, k) - v^k\|_2^2 \right]$

where $y$ denotes the text conditioning, and the expectation is over stages $k$ , noise levels $\lambda_t$ , intermediate noisy samples $x_t^k$ , upsampled previous outputs $\text{Up}(x^{k-1})$ , and conditioning inputs $y$ .

What this loss function computes: For each stage $k$ and noise level $\lambda_t$ , the model $u_\theta^k$ takes the noisy sample $x_t^k$ , the text conditioning $y$ , the current noise level $\lambda_t$ , and the stage index $k$ , and predicts a velocity vector. This prediction is compared to the constant ground-truth velocity $v^k$ using mean squared error. Minimizing this loss encourages the model to learn the correct transport direction from the upsampled previous scale to the full-resolution target at the current scale.

Why this form over standard flow matching: In standard flow matching, a single model learns the velocity field for the entire trajectory from pure noise $\epsilon$ to clean data $x_0$ at a fixed resolution. Pyramid Unified Predictor Corrector instead decomposes this into $K$ sub-problems, each learning the transport between adjacent scales. This is crucial for efficiency because early stages can operate at low resolution, reducing token count. The boundary conditions ensure continuity: when $k = 1$ , the "previous scale" is replaced by pure noise ( $\text{Up}(x^{k-1}) = \epsilon$ ), so stage 1 learns standard noise-to-data transport at low resolution. When $k = K$ , $x^k = x_0$ , so the final stage recovers the full-resolution output.

The timestep $T \in [0, 1000]$ associated with $\lambda_t$ is partitioned into stage boundaries $T_0 = 1000 > T_1 > T_2 > \dots > T_K = 0$ . Stage $k$ operates only on the interval $[T_k, T_{k-1}]$ . This means the early stages (low resolution) handle the high-noise regime ( $T$ near 1000), while later stages (high resolution) handle the low-noise regime ( $T$ near 0), which aligns with the intuition that coarse structure is determined early and fine details later.

Inference: multi-scale sampling with correction. At inference time, the total $N$ sampling steps are distributed across the $K$ stages as $(N_1, N_2, \dots, N_K)$ . At stage $k$ , sampling proceeds at discrete timesteps $\{t_k^n\}_{n=0}^{N_k}$ with the update rule:

$x_{t_k^n}^k = x_{t_k^{n-1}}^k + u_\theta^k(x_{t_k^{n-1}}^k, y, t_k^{n-1}) (t_k^n - t_k^{n-1})$

What this update represents: This is a first-order Euler integration of the ODE defined by the learned velocity field $u_\theta^k$ . At each step, the model predicts the velocity and takes a step of size $(t_k^n - t_k^{n-1})$ in that direction. Since the timesteps are decreasing (from high noise to low noise), this is a forward integration from noise toward clean data.

When transitioning from stage $k-1$ to stage $k$ , a naive approach would be to simply upsample the terminal state and continue sampling. However, the paper notes that "naively upsampling the terminal state may introduce artifacts and break path continuity." The solution, following PyramidFlow, is to "upsample the terminal state using nearest-neighbor interpolation and then correct the injected noise and its covariance to maintain distributional consistency across scales." This correction step adjusts the noise level of the upsampled state to ensure that it lies on the correct marginal distribution for the beginning of stage $k$ .

Token reduction analysis. For single-scale inference with $N$ steps at resolution $(H, W)$ , the total number of processed tokens is $\mathcal{O}(HWN)$ . For multi-scale inference with the standard pyramid where resolution halves at each stage (so stage 1 at $(H/2^{K-1}, W/2^{K-1})$ , stage 2 at $(H/2^{K-2}, W/2^{K-2})$ , ..., stage $K$ at $(H, W)$ ), and steps distributed evenly ( $N/K$ per stage), the total processed tokens are:

$\left( H \times W + \frac{H}{2} \times \frac{W}{2} + \frac{H}{4} \times \frac{W}{4} + \dots + \frac{H}{2^{K-1}} \times \frac{W}{2^{K-1}} \right) \times \frac{N}{K}$

What this sum represents: Each term is the spatial size at a given stage, and the largest term uses the highest resolution. The geometric series sums to approximately $\frac{4}{3}HW$ for large $K$ , meaning the total processed tokens across all stages is roughly $\frac{4}{3} \times \frac{N}{K} \times HW$ . Compared to single-scale $(N \times HW)$ , this is a reduction factor of approximately $K / 1.33$ . For $K = 3$ , this gives roughly a $2.25\times$ reduction. The paper reports (Section 4.1) that with $K = 3$ , the noisy-context token count decreases from $NHW$ to $\frac{7}{16}NHW$ , which represents a $2.29\times$ reduction—consistent with this analysis.

UniPC reset at stage boundaries. UniPC is a predictor-corrector sampler that reuses predictions from previous steps to correct the current update, improving convergence order. However, "since prediction tensors change shape across different stages, cached predictions cannot be reused across transitions." Helios therefore "resets the state buffer at each stage transition and re-accumulates the required state within the new stage." The paper notes this "empirically preserves sampling stability while avoiding cross-scale correction artifacts."

3.4.4 Deep Compression Flow (Step View): Adversarial Hierarchical Distillation

The token compression from Section 3.3 reduces per-step computation, but the model still requires many sampling steps (50 for Stages 1–2). To achieve real-time throughput, Helios distills the multi-step teacher into a few-step student using a modified Distribution Matching Distillation framework.

The Standard DMD Pipeline and Why It Must Be Adapted

In standard DMD (as described in Section 3.4.1):

Sample noise $\epsilon$ and feed it to a few-step generator $G_\theta$ , which produces a clean sample $x_0$ through forward simulation.
Sample a noise level $\lambda_\tau \sim \mathcal{U}[0, 1]$ and perturb $x_0$ to obtain a noisy sample $x_\tau$ .
Evaluate $x_\tau$ with a real-score estimator $p_{\text{real}}$ (the pretrained teacher, which scores how "real" the sample looks at noise level $\tau$ ) and a fake-score estimator $p_{\text{fake}}$ (trained online on the student's outputs to track the student's distribution).
The real score $s_{\text{real}}$ is computed via classifier-free guidance (CFG): $\text{CFG}(s_{\text{real}}^{\text{cond}}, s_{\text{real}}^{\text{uncond}})$ , combining conditional and unconditional score predictions.
The fake score $s_{\text{fake}}$ uses only the conditional branch of the fake-score estimator.
The difference $s_{\text{fake}} - s_{\text{real}}$ defines the distribution-matching gradient: it pushes the student's samples away from the "fake" distribution (what the student currently produces) toward the "real" distribution (what the teacher produces).
The fake-score estimator $p_{\text{fake}}$ is simultaneously trained with a flow-matching loss $\mathcal{L}_{\text{Flow}}$ on the student's outputs to stay calibrated to the student's evolving distribution.

Helios cannot use this pipeline directly because: (a) the teacher operates across multiple scales, so the backward simulation (estimating $x_0$ from $x_\tau$ ) must be staged; (b) the teacher is autoregressive and the student should learn to generate continuations, not isolated clips; (c) the standard DMD training with real data (which Self-Forcing and derivatives discard) can provide complementary supervision.

Pure Teacher Forcing with Autoregressive Teacher

The paper's first modification to DMD is to use only real data as historical context during the distillation stage, rather than generating multi-section rollouts as in Self-Forcing. The justification (Section 3.4.2): "Self-Forcing explicitly integrates the inference procedure... when training involves rollout of only five sections, the model frequently exhibits severe exposure bias during inference once the generated sequence exceeds this length." Increasing rollout length stabilizes generation but is computationally prohibitive for 14B models.

Helios's alternative: "employ real data exclusively as historical context during the distillation stage and require the generation of only a single section per training step." The key enabling factor is that Easy Anti-Drifting (Section 3.2) already trains the model to be robust to imperfect history, so the expensive self-forcing rollouts are unnecessary for achieving long-video stability. The teacher model for distillation is Helios-Base (the Stage 1 model), chosen because "it is already capable of generating high-quality long videos, whereas existing methods typically rely on Wan [90], which is limited to synthesizing short videos."

What this means operationally: During distillation training, the system takes a ground-truth video clip, uses its early frames as $X_{\text{Hist}}$ , and uses the remaining frames as the target $x_0$ to be generated. The student generates $x_0$ from noise conditioned on this real history. The teacher scores the result. This is dramatically cheaper than Self-Forcing because there is no autoregressive rollout—the history is always ground-truth, and only one section is generated.

Staged Backward Simulation

Standard DMD performs backward simulation (estimating $x_0$ from a noisy $x_\tau$ ) on a single flow trajectory. In Helios's multi-scale framework, the backward simulation must traverse the same $K$ stages used by the teacher, producing intermediate estimates $\{x_0^k\}_{k=1}^K$ . The final-stage output $x_0^K$ is used as the estimated clean sample.

At stage $k$ , given the current state $x_t^k$ and the predicted velocity $u_\theta^k(x_t^k, y, \lambda_t, k)$ , the terminal state is estimated as:

$x_0^k = x_t^k - \lambda_t \cdot u_\theta^k(x_t^k, y, \lambda_t, k)$

What this equation computes: In the linear interpolation path defined in Eq. 5, the relationship between the noisy state $x_t^k$ , the clean target $x_0^k$ , and the velocity $v^k$ is:

$x_t^k = (1 - \lambda_t) x_0^k + \lambda_t \cdot \text{Up}(x^{k-1}) = x_0^k - \lambda_t(x_0^k - \text{Up}(x^{k-1})) = x_0^k - \lambda_t \cdot v^k$

Rearranging: $x_0^k = x_t^k + \lambda_t \cdot v^k$ . Since the model predicts $\hat{v}^k = u_\theta^k(x_t^k, y, \lambda_t, k)$ , the estimate is $x_0^k = x_t^k + \lambda_t \cdot u_\theta^k(x_t^k, y, \lambda_t, k)$ . However, the paper's equation shows subtraction: $x_0^k = x_t^k - \lambda_t \cdot u_\theta^k$ . This sign discrepancy suggests the velocity is defined in the opposite direction (from clean to noisy rather than noisy to clean), which would be consistent with standard diffusion model parameterization where the model predicts the noise or velocity to remove. In any case, the operational meaning is: given the current noisy state and the model's prediction of the transformation direction, we can estimate where the clean sample would be.

The procedure "repeats this procedure until stage $k$ converges," and then the estimate $x_0^k$ initializes stage $(k+1)$ . After $K$ stages, $x_0 = x_0^K$ .

A critical negative result regarding multi-scale supervision: The paper explores whether feeding the intermediate estimates $x_0^k$ (not just the final $x_0^K$ ) to the real/fake score estimators provides richer supervision. They can interpolate intermediate results to the noise-free state using:

$x_0^{k'} = (x_0^k - \lambda_t \cdot \epsilon) / (1 - \lambda_t)$

However, "directly providing multi-scale $x_0^k$ to the fake-score estimator $p_{\text{fake}}$ causes the optimization to converge to an undesirable solution, resulting in a significant performance drop" (Section 5.4.7, Figure 18). The paper speculates this is because the fake-score estimator, when exposed to lower-resolution estimates, learns to distinguish real from fake at those resolutions and provides gradients that push the student toward low-resolution realism at the expense of high-resolution quality. The practical outcome is that only the final full-resolution estimate $x_0^K$ is used.

Coarse-to-Fine Learning: Curriculum Strategies for Stable Training

Multi-scale DMD is harder to optimize than single-scale DMD because "gradients propagate through $K$ stages and multiple flow trajectories." Helios employs three curriculum strategies:

1. Staged ODE Init. A compact dataset of ODE solution pairs is generated by Helios-Mid (the Stage 2 model). Each pair consists of a noise sample and the corresponding clean output generated by the teacher through the full multi-step sampling process. The student is initialized by training on these pairs, learning to reproduce the teacher's outputs in a single forward pass. The initialization is performed across $K$ stages, but "at each stage, only a single section needs to be generated rather than multiple sections, and an autoregressive teacher is employed to guide the process." This is analogous to the ODE distillation approach used in CausVid but adapted for multi-scale generation.

2. Dynamic Re-noise. Standard DMD samples noise levels $\lambda_\tau \sim \mathcal{U}[0, 1]$ uniformly. The paper argues this is "suboptimal in the hierarchical setting because different noise regimes contribute differently across training stages." Instead, timesteps are sampled from a Beta distribution whose parameters follow a cosine decay schedule. The schedule "concentrates on high-noise timesteps early to learn coarse structure and becomes increasingly uniform later to emphasize medium- and low-noise timesteps for detail refinement." This means the student first masters the coarse structure (which is learned at high noise levels) before being asked to refine fine details (learned at low noise levels), which is a natural curriculum.

What the Beta distribution controls: The Beta distribution over $[0, 1]$ has two shape parameters. By varying these parameters, the distribution can be concentrated near 0 (low noise, clean samples), near 1 (high noise, mostly noise), or anywhere in between. The cosine decay schedule gradually shifts the concentration from high noise to uniform, so the student sees progressively more challenging examples as training proceeds.

Adversarial Post-Training: Exceeding the Teacher's Quality Ceiling

Standard DMD distills the teacher's distribution into the student, meaning the student is fundamentally bounded by the teacher's quality—it can only be as good as the teacher, and in practice is usually slightly worse. To break this ceiling, Helios augments distillation with a GAN objective trained on real data.

Discriminator architecture. Multi-granularity classification branches $D$ are added to $p_{\text{fake}}$ (the fake-score estimator) and "distributed across DiT layers." Specifically (Table 2), GAN heads are placed at DiT layers 5, 15, 25, 35, and 39, each with hidden dimension 768. This means the discriminator has access to features at multiple levels of abstraction, from early low-level features (layer 5) to late high-level semantic features (layer 39).

GAN objective. The discriminator loss follows the non-saturated GAN formulation:

$\mathcal{L}_D = \mathbb{E} [\log D(x_\tau^{\text{real}}, \tau)] + \mathbb{E} [-\log D(x_\tau^K, \tau)]$

where $x_\tau^{\text{real}}$ is a real video perturbed to noise level $\tau$ , and $x_\tau^K$ is the student's output (after staged backward simulation) perturbed to the same noise level. The discriminator is trained to output high values for real samples and low values for fake samples.

To stabilize training, an approximate R1 regularizer is added:

$\mathcal{L}_{\text{aR1}} = |D(x_\tau^{\text{real}}, \tau) - D(\mathcal{N}(x_\tau^{\text{real}}, \sigma_D \mathbf{I}), \tau)|_2^2$

where $\mathcal{N}(x_\tau^{\text{real}}, \sigma_D \mathbf{I})$ is a perturbed version of the real sample with Gaussian noise of standard deviation $\sigma_D$ added. The R1 regularizer penalizes the gradient norm of the discriminator at real data points, encouraging a smooth decision boundary. The paper uses $\lambda_D = 100$ and $\sigma_D = 0.1$ .

The full discriminator loss is:

$\mathcal{L}_D = \mathbb{E} [\log D(x_\tau^{\text{real}}, \tau)] + \mathbb{E} [-\log D(x_\tau^K, \tau)] + \lambda_D \cdot \mathbb{E} [|D(x_\tau^{\text{real}}, \tau) - D(\mathcal{N}(x_\tau^{\text{real}}, \sigma_D \mathbf{I}), \tau)|_2^2]$

The generator loss is the standard non-saturating GAN loss:

$\mathcal{L}_G = \mathbb{E} [\log D(x_\tau^K, \tau)]$

What this GAN objective adds: DMD alone matches distributions in score-function space (the gradient of the log-density). The GAN objective adds matching in data space via a learned discriminator that directly distinguishes real from generated samples. This provides complementary supervision that is not bounded by the teacher's score function accuracy. In practice, the discriminator receives a random crop of size $H' \times W'$ where $H' = H/2$ and $W' = W/2$ , rather than the full-resolution sample, "to reduce memory usage."

Training dynamics. The student generator $G_\theta$ is initialized from Helios-Mid, and the real-score and fake-score estimators are initialized from Helios-Base. Following CausVid, the paper uses a two time-scale update rule (TTUR): $G_\theta$ is updated once every 5 updates of $p_{\text{fake}}$ .

The full training objectives are:

$\mathcal{L}_{G_\theta} = \mathcal{L}_{\text{DMD}} + w_G \cdot \mathcal{L}_G$

$\mathcal{L}_{p_{\text{fake}}} = \mathcal{L}_{\text{Flow}} + w_D \cdot \mathcal{L}_D$

with $w_G = 5 \times 10^{-2}$ and $w_D = 1 \times 10^{-2}$ . The DMD loss $\mathcal{L}_{\text{DMD}}$ is the standard distribution-matching gradient, the Flow loss $\mathcal{L}_{\text{Flow}}$ keeps the fake-score estimator calibrated to the student's current distribution, and the GAN losses provide real-data-driven quality improvement.

3.4.5 Inference-Time Techniques: Adaptive Sampling and Interactive Interpolation

Two lightweight, training-free mechanisms enhance robustness and interactivity at inference time.

Adaptive Sampling: Runtime Drift Detection and Correction

The paper observes (Figure 6) that drifting is accompanied by "pronounced shifts in RGB statistics (mean and variance)," and that "since the latent space is a compressed representation of RGB space, analogous distribution shifts also appear in latent statistics." Adaptive Sampling leverages this to detect drift during generation and intervene.

Drift detection. For each generated section, the RGB mean $\mu_t$ and variance $\sigma_t^2$ are computed. Global statistics $\bar{\mu}_t$ and $\bar{\sigma}_t^2$ are maintained via exponential moving average:

$\bar{\mu}_t = \rho_\mu \bar{\mu}_{t-1} + (1 - \rho_\mu) \mu_t$

$\bar{\sigma}_t^2 = \rho_\sigma \bar{\sigma}_{t-1}^2 + (1 - \rho_\sigma) \sigma_t^2$

where $\rho_\mu, \rho_\sigma \in (0, 1)$ are smoothing coefficients that control how quickly the global statistics adapt. If the current section's statistics deviate from the global statistics beyond preset thresholds:

$\|\mu_t - \bar{\mu}_t\|_2 > \delta_\mu \quad \text{and} \quad \|\sigma_t^2 - \bar{\sigma}_t^2\|_2 > \delta_\sigma$

the section is flagged as exhibiting significant drift.

Drift intervention. When the next section is generated, Frame-Aware Corrupt is applied to the historical context to "perturb the drifting frames in a targeted, training-free manner." The idea is that by corrupting the frames that caused the drift, the model is forced to rely more on "its intrinsic generative prior" rather than faithfully continuing a corrupted trajectory. This is a form of runtime error correction: detect distribution shift, then apply the same type of corruption the model was trained to handle, so it can recover gracefully.

Why this works: The model was trained with Frame-Aware Corrupt (Section 3.2.3) to produce clean continuations from corrupted history. Adaptive Sampling applies this mechanism strategically—not all the time (which would unnecessarily degrade quality on stable generations), but only when drift is detected. This is a closed-loop system: detect error → apply perturbation the model is robust to → let the model self-correct.

Interactive Interpolation: Smooth Prompt Transitions

Long-video generation with Helios enables a scenario where users can change the text prompt mid-generation, and the model should adapt smoothly without jarring visual discontinuities. A naive approach—abruptly switching from the current prompt embedding to the new one—"induces an instantaneous conditional shift and often causes visible discontinuities (e.g., flicker or sudden semantic jumps) around the editing boundary."

Linear interpolation between embeddings. Let the current prompt embedding be $\mathbf{e}^{(1)} \in \mathbb{R}^{\ell_{\text{Text}} \times D}$ and the target embedding be $\mathbf{e}^{(2)} \in \mathbb{R}^{\ell_{\text{Text}} \times D}$ , where $\ell_{\text{Text}}$ is the text length and $D$ is the hidden dimension. The system constructs $M$ intermediate conditions $\{\mathbf{e}^{[j]}\}_{j=0}^{M-1}$ via linear interpolation:

$\mathbf{e}^{[j]} = (1 - \lambda_j) \mathbf{e}^{(1)} + \lambda_j \mathbf{e}^{(2)}, \quad \lambda_j = \frac{j}{M-1}$

where $\lambda_j \in [0, 1]$ increases linearly. The first condition $\mathbf{e}^{[0]}$ is the original prompt, and the last $\mathbf{e}^{[M-1]}$ is the target prompt, with smooth intermediates in between. These are fed sequentially as the text conditioning during generation, with each intermediate used for one or a few generation steps.

What this accomplishes: The model's conditioning gradually transitions from the source prompt to the target prompt over $M$ steps. Because the transition is continuous in embedding space, the generated video frames change gradually rather than abruptly, preserving temporal coherence across the editing boundary. The paper does not specify the exact value of $M$ used in practice, but it is implicitly the number of autoregressive steps over which the transition occurs.

3.4.6 Summary of Design Choices and Their Justifications

Video continuation over causal masking: Preserves bidirectional attention within each generation step, maintaining the quality benefits of the pretrained model while avoiding the training-inference gap and cross-section coherence issues that causal masking introduces. The Representation Control mechanism provides a clean interface for multi-task generation without mode-switching logic.
Guidance Attention with amplified historical keys: Explicitly separates the roles of historical and noisy contexts in self-attention, giving the model per-head control over how much history influences current generation. This prevents both the semantic accumulation observed without Guidance Attention and the independent-section problem observed with causal masking.
Frame-Aware Corrupt over Self-Forcing: Achieves anti-drifting robustness through cheap, offline perturbation of training data rather than expensive online autoregressive rollouts. This is the key enabler for scaling to 14B, as Self-Forcing rollouts at this scale would be computationally prohibitive. The independent per-frame corruption decisions are critical for robustness across diverse error accumulation patterns.
Hierarchical token compression over uniform compression: Allocates the historical context token budget where it matters most (recent frames at high resolution for motion continuity, distant frames at low resolution for global context), achieving an 8× token reduction without sacrificing generation quality.
Multi-scale denoising over single-scale: Exploits the observation that early denoising steps primarily determine global structure and can operate at low resolution, reducing noisy-context tokens by 2.29× with minimal quality impact. The staged backward simulation in distillation mirrors this structure, maintaining consistency between training and inference.
Adversarial distillation over pure DMD: The GAN objective provides teacher-independent supervision that can push the student beyond the teacher's quality ceiling. The coarse-to-fine curriculum (Staged ODE Init, Dynamic Re-noise) addresses the increased optimization difficulty of multi-scale distillation.
First-Frame Anchor over learned anti-drifting: A simple, parameter-free mechanism that provides a stable reference for color and identity throughout autoregressive generation. The empirical evidence shows it is surprisingly effective: removing it causes degradation by frame 720, and the effect is robust across different video content.

4. Key Insights and Innovations

Innovation 1: The Fundamental Alternative to Causal Masking for Autoregressive Video Generation

The field's default answer to "how do you make a bidirectional DiT generate arbitrarily long videos?" has been causal masking—restrict attention so each frame only sees past frames, and the model becomes autoregressive by construction. This paper argues that causal masking is not merely suboptimal but is the root cause of a cascade of downstream problems that collectively prevent real-time, high-quality, long-video generation at scale.

The intellectual move here is to recognize that causal masking imposes a training-inference gap that must be closed by expensive mechanisms (Self-Forcing rollouts), which in turn constrain model scale (only 1.3B models are practical), which in turn limits representational capacity for complex motion and fine detail. The field has been solving symptoms rather than questioning the architectural premise. Helios's video continuation formulation—concatenating clean history with noisy future frames and processing them with bidirectional attention—sidesteps the entire causal masking problem space. The model never needs to "unlearn" bidirectional attention; it simply learns to denoise future frames conditioned on past frames, preserving the attention patterns it was pretrained with.

What makes this more than an architectural preference is the empirical demonstration that causal masking actively harms quality. The ablation in Table 5 and Figure 16 shows that adding causal masking to Helios makes training unstable and causes each section to "generate an independent new scene." This is not a tradeoff—causal masking is strictly worse for this architecture when combined with the other design choices. Conversely, Guidance Attention without causal masking (but with amplified historical key modulation) preserves cross-section coherence while preventing the semantic accumulation that occurs without any differentiation between history and noise. The paper is essentially showing that bidirectional attention over a [history + noise] concatenation, with appropriate modulation, is both more expressive and more stable than the causal alternative that the field has been iterating on for years.

This is a conceptual reframing at the level of the problem formulation, not an incremental improvement. It redefines what "autoregressive video generation" means: not frame-by-frame causal prediction, but section-by-section video continuation with full bidirectional context.

Innovation 2: Drifting as a Training Pathology, Not an Inference Inevitability

Prior work treats drifting as an unavoidable consequence of autoregressive error accumulation—the model conditions on imperfect outputs, small errors compound, quality degrades. The dominant solution has been to reduce the gap between training and inference conditions: Self-Forcing generates multi-section rollouts during training so the model experiences its own errors; error-banks store and replay past mistakes; inverted sampling reverses the inference direction to limit propagation. These are all reactive strategies that accept the premise that inference-time error accumulation is the problem to be solved.

Helios makes a fundamentally different diagnostic move. By characterizing three distinct failure modes—position shift (out-of-distribution positional encodings), color shift (cumulative distribution drift in color space), and restoration shift (brittleness to corrupted inputs)—the paper reframes drifting not as error accumulation per se but as a set of specific distribution shifts between training and inference that can be addressed at the data and encoding level. The implication is profound: if you can simulate these shifts during training, the model learns to be robust to them, and you never need to run expensive autoregressive rollouts.

The evidence for this reframing is in what Helios does not need. The distilled model achieves comparable anti-drifting performance to Self-Forcing with long rollouts (Figure 18, Table 5: Self-Forcing variant achieves 6.11 Total vs. Helios-Distilled at 6.34), but without generating multi-section sequences during training. This is only possible because Easy Anti-Drifting addresses the root causes rather than patching symptoms. Frame-Aware Corrupt, in particular, is conceptually revealing: it shows that the model does not need to see its own specific errors during training—it only needs to see the class of corruptions that occur during autoregressive inference (blur, exposure shifts, noise), synthesized cheaply from clean data. The independent per-frame corruption decision is the key design insight: by randomizing which frames are corrupted and how, the model sees combinatorially many corruption patterns, far more diverse than what any finite-length Self-Forcing rollout could produce.

This is a diagnostic reframing with practical consequences. It suggests that the entire line of work on train-as-infer rollouts, error-banks, and related mechanisms may be attacking a symptom rather than the disease—and that the disease itself is addressable through training data augmentation at a fraction of the computational cost.

Innovation 3: Token Compression as a Functional Decomposition, Not Just an Engineering Optimization

Token reduction for video generation is not new—prior work uses spatial downsampling, temporal subsampling, sparse attention, and hidden-state caching. But these are typically applied uniformly or with simple heuristics (e.g., uniform frame skipping). Helios's contribution is to recognize that history compression and noisy-context compression are fundamentally different problems driven by different principles, and that each admits a principled solution rooted in the information geometry of the generation process.

For historical context, the principle is temporal locality of information relevance: recent frames need high spatiotemporal resolution because they drive motion continuity and local consistency, while distant frames only need to convey coarse global context (scene identity, color palette, layout). Multi-Term Memory Patchification operationalizes this as a hierarchical compression scheme with progressively aggressive kernels for short-, mid-, and long-term memory. The result is an 8× token reduction with no quality loss because the compression follows the actual information decay curve—it discards resolution where information is redundant, not where it matters.

For noisy context, the principle is different: spatial resolution requirements vary across denoising stages. Early steps (high noise) determine global structure—layout, color, coarse object positions—which can be established at low resolution. Late steps (low noise) refine fine details—edges, textures, high-frequency patterns—which require full resolution. Pyramid Unified Predictor Corrector maps this observation onto a multi-scale flow matching framework, processing fewer tokens where resolution matters less. The 2.29× token reduction is achieved by redistributing computation across scales rather than by cutting corners.

What elevates this beyond an engineering contribution is the integration of these two compression principles into a single architecture where they compound. The historical context compression (8×) and noisy context compression (2.29×) are multiplicative in their effect on attention FLOPs—the paper reports roughly 64× and 5.2× reductions in attention FLOPs for historical and noisy contexts respectively (Section 4.1). This is what makes 14B real-time generation possible without specialized attention kernels. The conceptual decomposition into two distinct compression problems, each with its own optimal strategy, is what distinguishes this from prior work that treated token reduction as a single, monolithic optimization target.

Innovation 4: Adversarial Distillation as a Quality Ceiling Breaker in Video Generation

Step distillation for video generation is well-established—DMD and its variants reduce sampling steps from 50 to 4–8, and most existing real-time systems rely on it. The standard assumption is that the distilled student will be slightly worse than the teacher, and the goal is to minimize the quality gap. Helios challenges this framing by introducing an adversarial GAN objective that provides teacher-independent supervision from real data, enabling the student to surpass the teacher's quality on certain dimensions.

The significance here is not the GAN itself—GANs are decades old—but the demonstration that the teacher's quality ceiling is a real constraint in video distillation and that it can be broken without destabilizing training. The ablation in Table 5 and Figure 19 shows that removing Adversarial Post-Training causes "noticeable degradation in visual quality, particularly in naturalness and realism." The distilled model with the GAN objective achieves a Naturalness score of 5 (matching the base model's 5) versus 4 without it. The adversarial signal provides something that pure teacher-matching cannot: direct feedback on how "real" the output looks, unmediated by the teacher's potentially imperfect score function.

What makes this particularly interesting is the negative results that accompany it. The paper shows that Decouple DMD (a recent refinement that separates CFG augmentation from distribution matching in the DMD objective) causes slower convergence and grayish artifacts when applied to video (Figure 20, Table 5). Reinforcement learning via reward-weighted regression causes severe flickering and degrades semantic and aesthetic scores (Table 5). These failures highlight that post-training for video generation is fragile—what works for images does not trivially transfer—and that the specific combination of DMD + GAN with staged initialization and coarse-to-fine curriculum is non-obvious even if the individual components are known.

The innovation, then, is not any single technique in isolation but the integration of DMD, GAN, and multi-scale distillation into a stable training recipe that (a) eliminates the need for classifier-free guidance at inference (CFG scale drops from 5.0 to 1.0), (b) reduces sampling steps from 50 to 3, and (c) maintains or improves quality relative to the teacher on critical perceptual dimensions. The fact that this works at 14B scale, with four models in GPU memory simultaneously (generator, real-score estimator, fake-score estimator, EMA), and achieves 19.5 FPS, represents an empirical demonstration that adversarial distillation is viable for large-scale video generation—a claim that prior work had not established.

5. Experimental Analysis

Evaluation Methodology

Dataset. The paper constructs HeliosBench, a test set of 240 LLM-refined prompts sourced from Self-Forcing (Chen et al.). Prompts are evaluated across four duration tiers: very short (81 frames), short (240 frames), medium (720 frames), and long (1440 frames). The paper notes that no open-source benchmark targeting real-time long-video generation previously existed.
Base model(s). All Helios variants are initialized from Wan-2.1-T2V-14B, a 14B-parameter bidirectional video diffusion transformer. The authors argue this model is representative of contemporary large-scale video generation capabilities and provides a strong quality baseline for architectural adaptation. For the FLOPs-matched and quality comparisons, the $14\times$ larger model is not explicitly used in an inference-compute-scaling tradeoff as in some other papers; instead, the comparison is against the same-sized Wan 14B base model and various distilled models of different scales.
Metrics. Five automated dimensions are reported, following the methodology of Huang et al. (2024) and related evaluation frameworks: (1) Aesthetic, measured by the LAION aesthetic predictor; (2) Dynamic, computed using the Farnebäck optical flow algorithm; (3) Motion Smoothness, measured by RAFT optical flow; (4) Semantic (video-text alignment), measured by ViCLIP; and (5) Naturalness, measured by OpenS2V-Eval. Each metric is mapped to a 10-point scale using its empirical score distribution for improved robustness against raw-score noise. Additionally, for long-video evaluation, drifting variants of Aesthetic, Motion Smoothness, Semantic, and Naturalness are computed, following the methodology of FramePack (Zhao et al.). Throughput (FPS) measures end-to-end speed at 384×640 resolution under default frame lengths, including VAE and text encoder latency, with each model's officially supported acceleration techniques enabled.
Baselines. The paper compares against an extensive set of open-source models. Bidirectional models: SANA Video (2B), CogVideoX (2B), CogVideoX 1.5 (5B), Mochi-1 (10B), HV Video (13B), HV Video 1.5 (8.3B), Wan 2.1 1.3B, Wan 2.2 5B, Wan 2.1 14B, Wan 2.2 14B, LTX Video (1.9B), LTX Video 2 (19B), Kandinsky 5 lite (2B), Kandinsky 5 pro (19B), StepVideo T2V (30B), FastVideoWan 2.1 (14B, accelerated), TurboDiffusion 2.1 (14B, accelerated), and TurboDiffusion 2.1-Quant (14B, quantized and accelerated). Autoregressive models: NOVA (0.6B), Pyramid Flow (2B), MAGI-1 (4.5B), InfinityStar (8B), SkyReelsV2-DF (1.3B and 14B), CausVid (1.3B), Self Forcing (1.3B), Rolling Forcing (1.3B), LongLive (1.3B), Infinite Forcing (1.3B), Reward Forcing (1.3B), Causal Forcing (1.3B), Dummy Forcing Long (1.3B), SANA Video Long (2B), and Krea (14B). Autoregressive video continuation: LongCat-Video (13.6B).
Generation budget / compute accounting. Throughput is measured in frames per second (FPS) on a single NVIDIA H100 GPU. The generation budget for autoregressive models is implicitly defined by video duration — longer videos require more autoregressive steps. For the short-video benchmark (81 frames), long-video models are evaluated by truncating their outputs to the first 81 frames to ensure fair comparison with models whose default output length matches this duration. All models are benchmarked with their officially supported acceleration techniques (FlashAttention, torch.compile, KV-cache, warm-up) to reflect best-case deployment throughput.
Cross-validation / statistical protocol. No formal cross-validation is described for the main benchmark results. The user study (Section 5.3) randomizes presentation order and left-right placement, collects 200 valid responses with 40 pairwise comparisons per questionnaire, and restricts each participant to a single questionnaire to avoid information leakage.

Main Quantitative Results

Short Video Generation (81 frames)

Table 3 presents the core short-video results. The three Helios variants span the quality-efficiency spectrum: Helios-Base achieves a Total score of 6.35 at 0.54 FPS, Helios-Mid achieves 6.25 at 1.05 FPS, and Helios-Distilled achieves 6.00 at 19.53 FPS. The key comparison is that Helios-Distilled (6.00 Total) matches or exceeds all distilled models on the Total metric: CausVid achieves 4.50 at 24.41 FPS, Self-Forcing achieves 5.75 at 21.20 FPS, Reward Forcing achieves 5.55 at 22.13 FPS, and Krea achieves 5.95 at 6.74 FPS. Among base models, Helios-Distilled's 6.00 Total is competitive with Wan 2.1 14B (6.15 at 0.33 FPS), Wan 2.2 14B (6.35 at 0.33 FPS), and HV Video (6.00 at 0.36 FPS).

The throughput advantage is stark: Helios-Distilled runs at 19.53 FPS, making it approximately 59× faster than Wan 2.1 14B (0.33 FPS), 54× faster than HV Video (0.36 FPS), and 3.6× faster than FastVideoWan 2.1 (5.37 FPS), the fastest same-sized accelerated model. Notably, Helios-Distilled is also 1.28× faster than SANA Video Long (13.24 FPS), a 2B model that is seven times smaller.

On the perceptual metrics most correlated with human judgment, the paper emphasizes Semantic and Naturalness. Helios-Base scores 5 on Semantic and 6 on Naturalness, matching Wan 2.1 14B (6 and 5) and outperforming HV Video (5 and 5). Helios-Distilled achieves 5 on Semantic and 5 on Naturalness, which is equal to or better than all distilled models. The paper notes that distilled models "tend to produce videos with higher saturation and smaller motion amplitudes, which leads to higher Aesthetic and Smoothness scores compared to base models; however, this does not necessarily correlate with superior quality."

For Dynamic and Motion Smoothness, Helios avoids the pathological static behavior of some distilled models while maintaining stable motion: Helios-Distilled scores 7 on Dynamic and 10 on Smoothness, compared to Reward Forcing's 7 and 9, and Self-Forcing's 9 and 9. The distilled variants that score extremely high on Aesthetic (e.g., CausVid at 8, Dummy Forcing at 9) are flagged as potentially over-optimizing on saturation at the expense of genuine quality.

Figures 11 and 12 provide qualitative comparisons showing that Helios-Distilled generates videos comparable to base models in visual fidelity, text alignment, and motion dynamics, while the qualitative gap between Helios and other distilled models is visually apparent.

Long Video Generation (120–1440 frames)

Table 4 presents results aggregated across the four duration tiers. The Total column represents a weighted combination of quality and drifting scores. Helios-Distilled achieves a Total of 6.94, which is the highest among all autoregressive models, exceeding Reward Forcing (6.88), Rolling Forcing (6.86), LongLive (6.82), and Infinite Forcing (6.50). When throughput is factored in via the Throughput Score (a categorical rating of FPS), Helios-Distilled achieves a combined Total + Throughput Score of 6.94 + 6 = 12.94, outperforming all competing models on this combined metric.

The anti-drifting metrics — which measure how well the model preserves quality as video duration increases — are particularly informative. Helios-Distilled achieves Drifting Semantic 7 and Drifting Naturalness 7, compared to Reward Forcing's 9 and 6, and LongLive's 9 and 6. While Reward Forcing and LongLive achieve slightly higher Drifting Semantic scores (9 vs. 7), Helios-Distilled achieves a significantly better balance between anti-drifting and throughput: Helios-Distilled runs at 19.53 FPS versus Reward Forcing's 22.13 FPS (a modest 13% throughput difference) but achieves better overall quality (6.94 vs. 6.88 Total) and substantially better Naturalness (5 vs. 4) and Drifting Naturalness (7 vs. 6).

The progression across Helios variants is visible in Table 4: Helios-Base achieves 6.57 Total at 0.54 FPS with strong anti-drifting (Drifting Semantic 8, Drifting Naturalness 5); Helios-Mid shows a quality dip to 6.05 Total at 1.05 FPS, reflecting the token compression tradeoff (Drifting Semantic drops from 8 to 7, Aesthetic drops from 8 to 7); Helios-Distilled recovers to 6.94 Total at 19.53 FPS, exceeding Base on Drifting Naturalness (7 vs. 5) while largely preserving anti-drifting scores. This non-monotonic quality trajectory (Base → Mid drops, Mid → Distilled rises above Base on several metrics) demonstrates that the distillation process with adversarial post-training recovers and in some dimensions exceeds the quality lost to token compression.

The key comparison with LongCat-Video, the only other autoregressive video continuation model at comparable scale (13.6B), shows that Helios-Base (6.57 Total) is roughly on par with LongCat-Video (6.54 Total) in quality, while Helios-Distilled (6.94 Total) exceeds it substantially. However, the throughput difference is dramatic: Helios-Distilled runs at 19.53 FPS versus LongCat-Video's 0.33 FPS, a 59× speedup. This demonstrates that the video continuation approach, when combined with the full compression and distillation pipeline, achieves both quality parity and overwhelming throughput advantages.

Figures 13 and 14 provide qualitative evidence that Helios preserves visual quality, text alignment, and motion dynamics over long durations, while baseline methods exhibit noticeable degradation and inconsistencies in later frames.

User Study

Figure 15 presents side-by-side human evaluation results. On long-video generation, Helios is preferred over each of the five representative models (SANA Video Long, Dummy Forcing Long, Rolling Forcing, Reward Forcing, LongLive) by a clear margin in all comparisons. On short-video generation, Helios is preferred over all five baselines (SANA Video, LTX Video 2, LongCat-Video, Wan 2.2, HV Video 1.5). The user study uses 200 valid responses with randomized presentation order and left-right placement. The paper notes that each participant completes only one questionnaire to avoid information leakage and improve engagement.

Ablation Studies and Robustness Checks

Table 5 contains the quantitative ablation results for both Helios-Base and Helios-Distilled. Each ablation is a configuration change from the default model, and the table reports Total score plus all sub-metrics and drifting metrics. Non-obvious findings and negative results are highlighted below.

Guidance Attention with causal masking (w Guidance Attention*): Adding a causal mask to the self-attention in Guidance Attention — thereby preventing the noisy context from attending to the historical context in the forward direction — results in an unstable training process. This configuration is marked as "unstable training process" in Table 5, with no quantitative scores reported. Figure 16 shows qualitatively that causal masking causes each generated section to appear as an independent scene, breaking temporal coherence. This is a critical negative result demonstrating that bidirectional attention over the [history + noisy] concatenation is not merely a preference but a requirement for stable autoregressive generation at this scale.

Removing Guidance Attention entirely (w/o Guidance Attention): Total drops from 6.47 to 6.23. The primary failure is a sharp decline in Dynamic (6 → 4) and Drifting Naturalness (5 → 2). The paper attributes this to "excessive semantic accumulation over time (e.g., a progressively enlarged bird crest)" (Figure 16). Without the per-head amplification modulation of historical keys, the model cannot selectively suppress historical information that would otherwise compound across autoregressive steps.

Removing First-Frame Anchor (w/o First Frame Anchor): Total drops substantially from 6.47 to 5.51. The most affected metrics are Drifting Aesthetic (7 → 3) and Drifting Naturalness (5 → 2). Figure 17 shows qualitatively that removing the first-frame anchor not only introduces color shift (visible drifting in later frames) but also causes "the subject to deviate from the one in the initial frame, causing cumulative identity drifting." This is consistent with the mechanism described in Section 3.2.2: without the global visual anchor, there is no mechanism to pull the color distribution and subject identity back toward the reference established in the first frame.

Removing Frame-Aware Corrupt (w/o Frame-Aware Corrupt): This is the most damaging single ablation for Helios-Base. Total collapses from 6.47 to 4.70. Drifting Aesthetic drops to 2, Drifting Semantic to 3, and Drifting Naturalness to 1 — effectively complete loss of long-duration stability. The paper states (Figure 17) that "removing it causes severe drifting even at 240 frames, leading to a sharp drop in Aesthetic, Semantic, and Naturalness." This confirms that Frame-Aware Corrupt is not a supplementary robustness mechanism but the primary enabler of long-video generation in Helios-Base. The fact that training without any explicit corruption (no self-forcing, no error-banks, no frame-aware corrupt) produces a model that drifts severely even at moderate durations validates the paper's core anti-drifting hypothesis.

Replacing Pure Teacher Forcing with Self-Forcing (w Self-Forcing): In Helios-Distilled, replacing the Pure Teacher Forcing strategy (real data as history) with Self-Forcing (autoregressive rollouts during training) yields a Total of 6.11 versus 6.34 for the default. The primary degradation is in Semantic (4 vs. 5). Figure 18 shows that the self-forcing variant achieves "comparable robustness against long-video drifting" to Pure Teacher Forcing, but with slightly worse quality metrics. This is a non-obvious finding: Self-Forcing, which is the community standard for anti-drifting, is not superior to Pure Teacher Forcing when the underlying model has been trained with Easy Anti-Drifting. Moreover, Pure Teacher Forcing is dramatically cheaper, requiring "the generation of only a single section per training step" rather than multi-section rollouts. This result suggests that Self-Forcing's expensive rollouts are unnecessary if the model has learned robustness to corrupted history during pretraining/fine-tuning.

Replacing the Autoregressive Teacher with a Bidirectional Teacher (w Bidirectional Teacher): Total drops sharply from 6.34 to 4.75. Semantic collapses from 5 to 3, and Drifting Semantic drops from 7 to 4. This is a critical validation of the architectural choice: the teacher for distillation must be autoregressive (capable of video continuation) rather than bidirectional (limited to fixed-length generation). A bidirectional teacher like Wan-2.1-T2V-14B cannot provide meaningful guidance for the autoregressive continuation task, and the student's performance degrades accordingly.

Providing multi-scale estimates to score estimators (w Staged Backward Simulation*): In the standard Staged Backward Simulation, only the full-resolution final estimate $x_0^K$ is fed to the real and fake score estimators. The variant that also provides intermediate-scale estimates $x_0^k$ (interpolated to the noise-free state) results in an unstable training process. Table 5 marks this as "unstable training process" with no quantitative scores. Figure 18 shows qualitatively that "feeding multi-scale $x_0^k$ into the fake-score estimator $p_{\text{fake}}$ causes the model to converge toward incorrect directions." This is an important negative result: the intuition that multi-scale supervision would provide richer training signal is experimentally falsified, likely because the fake-score estimator, when exposed to low-resolution estimates, learns to distinguish real from fake at those resolutions and provides gradients that push the student toward low-resolution realism at the expense of full-resolution quality.

Removing Coarse-to-Fine Learning (w/o Coarse-to-Fine Learning): Total drops from 6.34 to 5.31. The degradation is across the board: Dynamic drops (6 → 4), Smoothness drops (10 → 8), Semantic drops (5 → 4), and Naturalness drops (5 → 4). Figure 19 shows qualitatively that "removing Coarse-to-Fine Learning prevents the model from converging, with particularly unacceptable quality in the first generated section." This confirms that the curriculum strategies (Staged ODE Init, Dynamic Re-noise) are not optional optimizations but are required for stable convergence of the multi-scale distillation process.

Removing Adversarial Post-Training (w/o Adversarial Post-Training): Total drops from 6.34 to 6.31 — a modest decline that masks a more interesting pattern. Dynamic actually increases (6 → 8), but Naturalness drops (5 → 4) and Drifting Naturalness increases (7 → 9). Figure 19 shows "degradation in visual quality." The nuanced interpretation is that the GAN objective primarily improves perceptual realism (Naturalness) at a small cost to motion amplitude (Dynamic). Removing it shifts the model toward more dynamic but less natural outputs, suggesting that the adversarial signal constrains the model toward physically plausible motion.

Replacing DMD with Decouple DMD (w Decouple DMD): Total collapses from 6.34 to 5.21. Dynamic increases (6 → 9) but Smoothness drops sharply (10 → 7), and Semantic drops (5 → 4). Figure 20 shows that Decouple DMD "may hinder convergence and cause grayish outputs." This is a negative result showing that a technique reported to improve image generation (Decouple DMD reformulates the DMD objective as a weighted sum of CFG Augmentation and Distribution Matching components) does not transfer to video generation. The paper attributes this to slower convergence and suboptimal temporal/spatial consistency in the video domain.

Adding reward-weighted regression (w Reward-weighted Regression): Total drops from 6.34 to 6.23. Dynamic increases to 10 (the maximum possible), but Figure 20 shows that this variant "may intensify video flickering." The paper uses VideoAlign as the reward model with Motion Quality as the score. The failure of RL-based post-training to improve quality — despite the intuitive appeal of directly optimizing a learned reward — highlights that the distribution-matching approach of DMD is better behaved for video generation than policy-gradient-style optimization, which can exploit reward model weaknesses to produce high-scoring but visually flawed outputs.

Flash Normalization and Flash RoPE (Table 6): These are infrastructure ablations measuring runtime, not quality. Measured on Wan-2.1-T2V-14B at 384×640 with 81-frame inputs over 50 forward passes (inference) and 50 forward-backward passes (training): the baseline DiT runtime is 98.68s (inference) and 398.03s (training). Flash Normalization alone reduces inference to 89.91s and training to 360.77s. Flash RoPE alone reduces inference to 93.39s and training to 378.77s. Combined, they achieve 84.41s inference (14.5% reduction) and 340.38s training (14.5% reduction). The paper attributes this improvement to reduced memory traffic from kernel fusion and the elimination of intermediate tensor storage.

Token compression magnitudes (Section 4.1): The paper reports historical-context token count reduction from $5HW$ to $\frac{5}{8}HW$ (approximately 8×), and noisy-context token count reduction from $NHW$ to $\frac{7}{16}NHW$ (approximately 2.29× with $K=3$ ). In attention FLOPs terms, these translate to roughly 64× reduction for historical context and 5.2× reduction for noisy context. The paper also claims that "a history length of up to 18 is supported while keeping compute and memory costs stable, whereas naive historical-context modeling causes OOM errors at context length 6" (Section 5.4.4, Figure 7). No quantitative quality ablation is reported specifically for Multi-Term Memory Patchification alone, as it is integrated into the architecture from Stage 1 and its contribution is assessed indirectly through the Base → Mid throughput improvement.

Critical Assessment

Claim 1: Helios achieves 19.5 FPS on a single H100 GPU with a 14B model without standard acceleration techniques.

This claim is strongly supported by the throughput measurements in Table 3 (Helios-Distilled: 19.53 FPS) and Table 4 (same). The paper is transparent about what counts as "standard acceleration techniques" — KV-cache, sparse/linear attention, quantization — and Helios does not use these. It does use FlashAttention (Section 4.4), which is arguably a standard optimization, but the paper frames the claim as not using techniques that fundamentally change the attention mechanism or model precision. The comparison to same-sized accelerated models (FastVideo: 5.37 FPS, TurboDiffusion: 10.15 FPS) provides concrete evidence that the throughput advantage comes from architectural compression rather than engineering optimizations alone.

However, the throughput measurement is for the distilled model only (Stage 3). The base model (Helios-Base: 0.54 FPS) and mid model (Helios-Mid: 1.05 FPS) are far from real-time. The real-time claim is specifically about the final distilled model, and the distillation process adds substantial training complexity and infrastructure requirements (128 H100s, four 14B models in GPU memory). The claim is therefore about inference throughput, not training efficiency.

A weakness is that the paper does not report the latency of the distillation process itself or the computational cost of Stage 3 training. The infrastructure section describes memory-saving techniques (sharded EMA, asynchronous VRAM freeing, Cache Grad for GAN) but does not provide training wall-clock time or total FLOPs for the distillation stage. For practitioners evaluating whether to adopt this approach, the training cost is a relevant consideration not quantified in the paper.

Claim 2: Helios generates minute-scale videos with high quality and strong coherence without commonly used anti-drifting strategies.

This claim is supported with qualifications. The quantitative evidence in Table 4 shows that Helios-Base (Drifting Semantic 8, Drifting Naturalness 5) and Helios-Distilled (Drifting Semantic 7, Drifting Naturalness 7) achieve strong anti-drifting scores without Self-Forcing, error-banks, keyframe sampling, or inverted sampling. The ablation study confirms that Frame-Aware Corrupt is essential for this performance: removing it causes Total to drop from 6.47 to 4.70 and long-duration stability to essentially collapse (Table 5, Figure 17).

The qualifications are: (1) The "minute-scale" claim is demonstrated up to 1440 frames (the longest tier in HeliosBench). At 24 FPS, this is 60 seconds — one minute, not "minutes." The paper does not provide quantitative results beyond 1440 frames, so "minute-scale" should be understood as "up to approximately one minute," and the extrapolation to "minutes" is based on qualitative observation that the anti-drifting mechanisms do not show degradation trends that would prevent longer generation. (2) The anti-drifting metrics are automated and the paper acknowledges they are "noisy and their raw scores may correlate poorly with human perception." The 10-point mapping is a heuristic that the paper does not validate against human judgments of drift. (3) The First-Frame Anchor, while simple, imposes a constraint: the first frame must be retained throughout generation, which means the model cannot naturally evolve scene identity or color palette if the prompt describes a location change — a limitation not discussed in the paper.

Claim 3: The distilled model delivers a 128× speedup over Wan 14B.

This claim is supported but narrow. The 128× figure appears to be the ratio of Helios-Distilled's 19.53 FPS to Wan 2.1 14B's approximately 0.15 FPS for 50-step generation (the paper reports 0.33 FPS for Wan, but this likely includes some acceleration; the 128× figure is cited in the introduction and may use a pre-acceleration baseline). Table 3 shows Helios-Distilled at 19.53 FPS versus Wan 2.1 14B at 0.33 FPS, which is a 59× speedup. The 128× figure may account for the reduction in sampling steps (50 to 3) and the elimination of CFG overhead (CFG scale 5.0 to 1.0), which are multiplicative factors not fully captured by a simple FPS ratio.

The narrowness of this claim: the speedup is measured for the distilled model only, which requires the full three-stage training pipeline. The speedup is relative to a specific baseline (Wan 2.1 14B) running at a specific configuration. The paper does not report on how much of the speedup comes from token compression versus step reduction versus CFG elimination, making it difficult to attribute the gains to specific components.

Claim 4: Helios consistently outperforms prior methods on both short- and long-video generation.

This claim is supported for the automated metrics and user study, but with important caveats about metric reliability. The Total scores in Table 3 (short: 6.00–6.35) and Table 4 (long: 6.05–6.94 for Helios variants) are competitive with or exceed all baselines at comparable throughput. The user study (Figure 15) shows consistent human preference for Helios over five baselines each for short and long generation, with 200 valid responses.

The caveat: the Total metric is a weighted sum of five automated metrics, each of which is noisy and imperfectly correlated with human judgment. The paper acknowledges this limitation: "existing benchmarks are only weakly aligned with human preference." The mapping to a 10-point scale is a post-hoc normalization that makes the numbers more interpretable but does not address the underlying issue that automated video quality metrics are not reliable proxies for perceptual quality. The user study partially addresses this but with only 200 responses across multiple comparisons, the per-comparison sample size is modest.

What is missing from the experimental evaluation:

No ablation on the specific compression ratios for Multi-Term Memory Patchification. The paper reports that $(p_t, p_h, p_w)$ are set to $(4,8,8)$ , $(2,4,4)$ , and $(1,2,2)$ for short-, mid-, and long-term memory respectively, but does not explore how sensitive performance is to these choices or whether more aggressive compression is possible.
No comparison to streaming or chunked generation baselines that simply run a bidirectional model on the concatenation of previous output and new noise without the specific Guidance Attention modulation. The ablation of "w/o Guidance Attention" removes the amplification tokens entirely, but does not test whether a simpler separation mechanism (e.g., separate forward passes for history and noise, or explicit feature normalization) would suffice.
No ablation on the number of pyramid stages $K$ . The paper sets $K=3$ and reports the token reduction factor, but does not test $K=2$ or $K=4$ to determine whether this is optimal.
No diversity or coverage metrics. All quality metrics measure fidelity and alignment, but there is no evaluation of whether Helios generates diverse outputs for the same prompt or whether the distillation process causes mode collapse — a common concern with GAN-based distillation. The paper does not report FID, IS, or any distribution-level diversity metric.
No failure case analysis. The paper does not present or discuss prompts or video types where Helios fails (beyond the ablation studies showing what happens when components are removed). This is a significant omission for a system making strong real-time claims; understanding failure modes is essential for practical deployment.
Limited duration testing. The 1440-frame (60-second) maximum is the only "minute-scale" tier tested. A system claiming "minute-scale" generation would ideally demonstrate stability at 2–5 minutes with quantitative metrics, even if only on a subset of prompts.
Single GPU architecture (H100). All throughput numbers are on H100. Performance on consumer GPUs or other accelerator architectures is not reported, limiting the practical deployability claims.
No training cost or carbon footprint reporting. For a paper introducing a new 14B model training pipeline, the absence of any training compute or energy consumption data is a notable omission given current community norms around environmental impact disclosure.

6. Limitations and Trade-offs

6.1 The Difficulty Estimation Cost Is Unaccounted for in the Headline Throughput Numbers

The assumption or constraint. The compute-optimal framework in this paper depends on pre-computed "oracle" and "predicted" difficulty bins for each prompt in HeliosBench. While the paper does not explicitly frame this as an estimation problem the way some scaling-law papers do, the throughput and quality numbers for Helios-Distilled (19.53 FPS, Total 6.00–6.94) are reported after the full training pipeline is complete, and the model's autoregressive behavior depends on the Easy Anti-Drifting mechanisms being trained into the weights. The paper acknowledges in Section 5.1 that training Stage 1 and Stage 2 uses 64 H100 GPUs and Stage 3 uses 128 H100 GPUs, but it never quantifies the total training compute cost in GPU-hours, FLOPs, or wall-clock time. The headline claim of "19.5 FPS on a single H100" is purely an inference throughput number that excludes the amortized cost of the three-stage training procedure.

The consequence. A practitioner deciding whether to adopt Helios needs to understand the total cost of ownership. The three-stage pipeline—architectural adaptation (Stage 1, 13k steps), token compression (Stage 2, 36k steps), and adversarial distillation (Stage 3, ~6k steps with four 14B models in GPU memory)—likely represents millions of GPU-hours of training compute. For a team with access to a single H100, the inference speed is irrelevant if they cannot afford to train the model. For a team with large-scale compute, the training cost determines whether the 128× inference speedup over the Wan baseline justifies the upfront investment. The paper does not provide the data needed to make this calculation.

What evidence exists in the paper. Tables 1 and 2 report training steps, batch sizes, GPU counts, and optimizer configurations for each stage, enabling a rough lower-bound estimate. Stage 1: 13k steps × batch 128 on 64 H100s. Stage 2: 36k steps × batch 192–256 on 64 H100s. Stage 3: ~6k steps × batch 128 on 128 H100s, with four 14B models in GPU memory simultaneously (generator, real-score estimator, fake-score estimator, EMA model). The infrastructure section (Section 4) describes memory-saving techniques to make Stage 3 fit, but does not translate these into total compute cost. The Wan-2.1-T2V-14B base model was itself trained on a large compute budget not accounted for here.

Mitigation status. Not addressed. The paper focuses exclusively on inference-time performance and does not discuss training cost, carbon footprint, or the tradeoff between training investment and inference savings. A practitioner would need to estimate total training FLOPs from the provided hyperparameters and compare against the inference savings for their expected deployment volume to determine whether the approach is cost-effective.

6.2 The Anti-Drifting Guarantee Is Demonstrated Only to 60 Seconds, Not "Minutes"

The assumption or constraint. The paper's abstract claims "minute-scale generation," and Section 5.1 states that HeliosBench evaluates "four duration regimes: very short (81 frames), short (240 frames), medium (720 frames), and long (1440 frames)." At 24 FPS, 1440 frames corresponds to exactly 60 seconds—one minute, not multiple minutes. The paper does not provide quantitative results beyond 1440 frames for any metric. The claim that the model can generate "minutes" of video is extrapolated from the observation that anti-drifting metrics do not show monotonic degradation trends, but this extrapolation is not empirically validated.

The consequence. The primary failure mode of autoregressive video generation—drifting—is known to be a cumulative phenomenon that often appears after a threshold duration. The fact that Helios maintains anti-drifting scores of Drifting Semantic 7 and Drifting Naturalness 7 at 1440 frames is encouraging but does not guarantee stability at 3000 frames (2+ minutes) or longer. The First-Frame Anchor mechanism, which retains the very first frame throughout generation, may become increasingly irrelevant or even counterproductive as the generated content naturally diverges from the initial frame (e.g., if the prompt describes a journey through different environments). Frame-Aware Corrupt was trained with specific corruption magnitudes ( $b_{\max} = 0.33$ noise, $a_{\max} = 1.7$ exposure shift in Stage 3; Table 2); if error accumulation beyond 1440 frames produces corruption patterns outside this training distribution, the model's robustness may degrade.

What evidence exists in the paper. Table 4 reports anti-drifting metrics aggregated across the four duration tiers, not broken out by tier. This means we cannot see whether Helios's Drifting Semantic score of 7 represents stable performance across all four tiers or is buoyed by strong performance on shorter durations while degrading at 1440 frames. The qualitative figures (13, 14) show examples up to 1440 frames, but these are cherry-picked showcases rather than systematic evaluation. The Adaptive Sampling mechanism (Section 3.5), which detects and corrects drift at runtime, is described conceptually but never evaluated quantitatively—there is no ablation showing that Adaptive Sampling improves anti-drifting at extended durations beyond 1440 frames.

Mitigation status. The paper acknowledges implicitly that 1440 frames is the testing ceiling, but does not frame this as a limitation. The Adaptive Sampling technique (Section 3.5) is presented as a mechanism for runtime drift correction that could, in principle, extend viable generation duration, but its effectiveness beyond 1440 frames is unmeasured. A practitioner would need to conduct their own extended-duration evaluation before deploying Helios for multi-minute generation.

6.3 Single Model Family, Single Initialization, Single Domain

The assumption or constraint. All Helios variants are initialized from Wan-2.1-T2V-14B, a specific 14B bidirectional video diffusion model. All training and evaluation use video data of duration < 10 seconds (Section 5.1) for training, and HeliosBench consists exclusively of text-to-video prompts. While the Representation Control module theoretically supports I2V and V2V (Section 3.1.1), the quantitative evaluation in Tables 3 and 4 is exclusively T2V. The paper shows qualitative I2V and V2V examples (Figures 22, 23) but provides no automated metrics or user study results for these modes. All experiments are conducted with a single model architecture (DiT), a single pretrained backbone, and a single domain (general text-to-video with prompts sourced from Self-Forcing).

The consequence. The paper's contributions—particularly Guidance Attention's amplified key modulation, Easy Anti-Drifting's corruption strategies, and the Pyramid Unified Predictor Corrector's multi-scale flow matching—are tightly coupled to the DiT architecture and the Wan2.1 weight initialization. It is unknown whether these techniques would transfer to other backbone architectures (e.g., U-Net-based diffusion, autoregressive transformers like NOVA), other pretrained models (e.g., CogVideoX, Mochi, HV Video), or other domains (e.g., egocentric video, surgical video, driving scenes). The anti-drifting strategies were calibrated with specific corruption parameters (Tables 1, 2) that may not generalize to models with different latent spaces or generation characteristics. The I2V and V2V capabilities are demonstrated qualitatively but not benchmarked, leaving their practical reliability unclear. For a practitioner considering Helios for a domain-specific application (e.g., medical imaging, satellite video), the lack of domain diversity in the evaluation is a significant uncertainty.

What evidence exists in the paper. Section 5.2 and Tables 3–4 evaluate Helios against 30+ baselines, but all on the same HeliosBench prompt set in T2V mode. Figures 22 and 23 show qualitative I2V and V2V examples with prompts partially sourced from other works, but there is no quantitative comparison to I2V/V2V-capable baselines. The paper does not include an ablation where the Wan2.1 initialization is replaced with another pretrained model to test whether the training recipe is backbone-agnostic.

Mitigation status. Not addressed. The paper's contributions are presented as general techniques, but the experimental validation is limited to a single initialization and task mode. The paper does not claim generalizability beyond the tested configuration, but the strong language in the introduction ("Helios is a 14B recipe for real-time long-video generation") invites the interpretation that the recipe is transferable. A practitioner would need to replicate the three-stage training pipeline on their target backbone to determine transferability.

6.4 No Diversity or Mode-Collapse Evaluation After Adversarial Distillation

The assumption or constraint. Stage 3 applies Adversarial Hierarchical Distillation, which combines DMD-based distribution matching with a GAN objective trained on real data (Section 3.4.2). GAN-based distillation is well-known in the image generation literature to risk mode collapse—the student model learns to produce high-quality samples that cover only a subset of the teacher's output distribution. The paper evaluates quality (Aesthetic, Semantic, Naturalness, etc.) and anti-drifting, but provides no diversity metrics: no FID, no IS, no coverage or recall measures, no evaluation of whether Helios produces diverse outputs when given the same prompt with different random seeds.

The consequence. A practitioner deploying Helios for interactive generation needs to know whether the model will produce varied, controllable outputs or whether it collapses to a narrow set of "safe" generations that satisfy the quality metrics but lack creative diversity. The adversarial objective (Equation 14: $\mathcal{L}_G = \mathbb{E}[\log D(x_\tau^K, \tau)]$ ) encourages the generator to produce samples that the discriminator classifies as real, which can incentivize mode dropping if the discriminator learns to reject modes it has not recently seen. The paper's ablation on removing Adversarial Post-Training (Table 5, Section 5.4.9) shows a drop in Naturalness (5 → 4) but does not measure whether diversity increases or decreases. The reward-weighted regression ablation (Section 5.4.12) shows that RL-based optimization causes "severe flickering," which could be a consequence of distribution collapse but is not analyzed through that lens.

What evidence exists in the paper. None. There are no diversity metrics reported anywhere in the paper. The user study (Section 5.3, Figure 15) asks participants to compare videos side-by-side but does not ask about output diversity across multiple generations of the same prompt. The qualitative examples (Figures 3, 11–14, 21–23) show single generations per prompt, providing no evidence about output variation. The paper mentions that the GAN head layers are distributed across DiT layers 5, 15, 25, 35, and 39 (Table 2) for "multi-granularity" discrimination, which might help preserve diversity by providing feedback at multiple abstraction levels, but this is not evaluated.

Mitigation status. Not addressed. The paper does not acknowledge mode collapse as a potential risk, does not report diversity metrics, and does not discuss diversity in the limitations or future work sections. This is a significant omission given the centrality of adversarial distillation to the final model's quality claims and the well-documented tendency of GANs to mode-collapse. A practitioner deploying Helios in a creative application where output diversity matters (e.g., an artist exploring variations on a prompt) would need to independently evaluate this risk.

6.5 The First-Frame Anchor Imposes a Fixed-Identity Constraint That Conflicts with Narrative Video Generation

The assumption or constraint. Section 3.2.2 introduces the First-Frame Anchor, which retains the very first frame of the video in the historical context $X_{\text{Hist}}$ throughout autoregressive generation. The mechanism works by providing a "global visual anchor" that constrains color distribution and subject identity. The paper demonstrates its effectiveness: removing it causes Total to drop from 6.47 to 5.51 and Drifting Aesthetic to collapse from 7 to 3 (Table 5, Section 5.4.2). However, this mechanism fundamentally assumes that the visual identity and color statistics established in the first frame should persist throughout the entire video. For many narrative applications—a character walking from day to night, a journey through different environments, a scene that deliberately transitions in mood or color palette—this assumption is violated by design.

The consequence. The paper evaluates Helios on HeliosBench prompts, which are sourced from Self-Forcing and LLM-refined (Section 5.1). The content of these prompts is not analyzed for whether they require identity or color consistency. If HeliosBench skews toward prompts describing consistent scenes (e.g., "a car driving through a forest," "a woman walking on a beach"), the anti-drifting evaluation may overstate robustness for prompts requiring deliberate visual evolution. Conversely, if HeliosBench includes prompts that require identity shifts, the First-Frame Anchor may actively harm quality by anchoring later frames to an inappropriate reference. The Interactive Interpolation mechanism (Section 3.5) enables prompt changes during generation, but it operates in text embedding space through linear interpolation (Equation 20). If the user changes the prompt to describe a fundamentally different scene, the First-Frame Anchor's pixel-space constraint may conflict with the text-embedding transition, producing visual artifacts not evaluated in the paper.

What evidence exists in the paper. Figure 17 shows that removing the First-Frame Anchor causes subject identity drifting and color degradation, which is evidence for its effectiveness on the tested prompts. However, no ablation tests the First-Frame Anchor on prompts that explicitly require visual evolution (e.g., "a timelapse from sunrise to sunset," "a character aging from child to adult"). The paper does not analyze what fraction of HeliosBench prompts require stable vs. evolving visual identity. The Interactive Interpolation examples (Figure 23) show prompt transitions within consistent scenes (weatherman's actions changing, woman's actions changing), not radical scene transitions that would stress the First-Frame Anchor.

Mitigation status. Not addressed. The paper presents the First-Frame Anchor as universally beneficial without discussing its failure modes. A practitioner generating narrative content with deliberate visual evolution would need to either disable the First-Frame Anchor (accepting the drift risk documented in Table 5) or develop a mechanism for updating the anchor frame at scene boundaries—neither of which the paper explores.

6.6 Automated Metrics Are Weak Proxies for Perceptual Quality, and the User Study Is Modest

The assumption or constraint. The paper's quantitative evaluation relies on five automated metrics—Aesthetic (LAION predictor), Dynamic (Farnebäck), Motion Smoothness (RAFT), Semantic (ViCLIP), and Naturalness (OpenS2V-Eval)—each mapped to a 10-point scale using empirical score distributions (Section 5.1). The paper explicitly acknowledges that "existing benchmarks are only weakly aligned with human preference" and that these metrics "are noisy and their raw scores may correlate poorly with human perception." The user study (Section 5.3) with 200 responses and 40 pairwise comparisons per questionnaire provides human validation but has modest per-comparison statistical power and evaluates only five baselines per task (long and short), leaving the other 25+ baselines in Tables 3–4 without human validation.

The consequence. Small differences in Total score—the weighted sum of five automated metrics—may not reflect genuine perceptual differences. For example, Helios-Distilled's Total of 6.94 vs. Reward Forcing's 6.88 (Table 4) is a 0.06 difference on a 10-point composite scale derived from noisy automated metrics. The paper does not report confidence intervals, standard deviations, or statistical significance tests for any metric, making it impossible to determine whether such small margins are reliable. The 10-point mapping, while improving interpretability, introduces an additional degree of freedom that could amplify or suppress differences depending on how the empirical score distributions are computed. The user study partially addresses this with direct human comparisons, but (1) it covers only a subset of baselines, (2) the 200 responses, while reasonable, provide limited per-comparison power after distributing across 10 model × baseline comparisons, and (3) the study evaluates overall preference, not specific dimensions (aesthetic quality, motion quality, text alignment), so it cannot validate whether the automated metric rankings align with human judgment on individual quality dimensions.

What evidence exists in the paper. The paper is transparent about the metric limitation, stating it explicitly in Section 5.1. The user study (Figure 15) shows consistent Helios preference over the tested baselines, which provides some convergent validity for the automated metric rankings. However, the per-comparison sample sizes in the user study are not reported, and the paper does not compute correlation coefficients between automated metrics and human judgments.

Mitigation status. Partially addressed through the user study, but the gap between automated metrics and human perception remains the primary uncertainty in interpreting the quantitative results. A practitioner evaluating whether Helios's quality advantage over a competing method (particularly when the Total score difference is small) should rely primarily on the user study results and qualitative examples rather than the precise numerical rankings in Tables 3–4.

7. Implications and Future Directions

How This Work Changes the Landscape

This paper performs a conceptual reframing that reopens an architectural path the field had largely abandoned. The dominant approach to autoregressive video generation since CausVid has been causal masking applied to pretrained bidirectional DiTs, combined with Self-Forcing rollouts and DMD distillation. The community has invested heavily in refining this paradigm—Rolling Forcing, LongLive, Infinite Forcing, Reward Forcing, Causal Forcing, Dummy Forcing, each iterating on the same causal-masking-plus-distillation template. Helios argues, and demonstrates empirically, that this entire line of work is optimizing a fundamentally suboptimal architecture. The key empirical evidence is the Guidance Attention ablation in Table 5: adding a causal mask to Helios's attention mechanism makes training unstable. Removing it entirely causes semantic accumulation. The solution is neither more rollouts nor more sophisticated distillation, but a different attention mechanism (amplified historical key modulation with bidirectional attention) that preserves the pretrained model's representational capacity while giving the model explicit control over historical influence.

This is not a paradigm shift in the sense of introducing a radically new generative framework—Helios is still a diffusion model, still uses flow matching, still employs DMD distillation. It is a diagnostic reframing that identifies causal masking as the root cause of a cascade of downstream problems: causal masking creates a training-inference gap → closing it requires Self-Forcing rollouts → long rollouts constrain model scale to ~1.3B → small models lack capacity for complex motion and fine detail → aggressive distillation is needed to recover speed → the distilled model inherits the causal-masking quality ceiling. By breaking the first link in this chain, Helios enables solutions at every subsequent level: the training-inference gap disappears (because bidirectional attention is preserved), Self-Forcing becomes unnecessary (because Easy Anti-Drifting handles error accumulation through data augmentation), 14B-scale training becomes viable, and distillation can focus on speed rather than compensating for architectural limitations.

The paper resolves a tension that has been visible in the literature but rarely articulated: why do causal-masking-based autoregressive models consistently underperform bidirectional models on short-video benchmarks, even when the autoregressive models are explicitly designed for long-video generation? Table 3 shows that 1.3B autoregressive models (Self-Forcing: 5.75 Total, Reward Forcing: 5.55) lag behind comparable bidirectional models (Wan 2.1 1.3B: 6.10 Total) on 81-frame clips. The standard explanation has been the capacity gap from distillation. Helios's results suggest a deeper explanation: causal masking itself reduces the expressive capacity of the attention mechanism, and this capacity reduction cannot be fully recovered through distillation or longer training. The bidirectional video continuation approach (Helios-Base: 6.35 Total at 81 frames, comparable to Wan 2.1 14B at 6.15) demonstrates that autoregressive generation does not inherently require a quality sacrifice—the sacrifice was an artifact of the causal masking architectural choice.

The practical consequence for the field is that the causal masking paradigm for autoregressive video generation becomes significantly less attractive as a research direction. The paper shows that the video continuation approach achieves better quality (Tables 3, 4), comparable anti-drifting (Table 4), and dramatically better scalability to large models, all without the expensive training procedures (long self-forcing rollouts) that have been the focus of extensive engineering effort. A researcher entering this area today would need strong evidence that causal masking offers advantages not captured in Helios's evaluation to justify continuing within that paradigm.

Conversely, several research directions become newly tractable or more promising because of this work:

Large-scale autoregressive video models are now trainable. The fact that Helios trains a 14B model with batch sizes comparable to image diffusion models (Section 4.1), without model parallelism or sharding, means that the infrastructure barrier to entry for high-quality autoregressive video generation has dropped substantially. Research groups with access to 8–64 GPUs can now train models at scales previously requiring industrial compute clusters.
Anti-drifting through data augmentation is a viable alternative to architectural solutions. The community has treated drifting as a problem requiring inference-time interventions (error-banks, keyframe sampling, test-time training) or expensive training procedures (Self-Forcing rollouts). Helios shows that explicitly simulating inference-time corruption during training—at the data level, through Frame-Aware Corrupt—is simpler, cheaper, and more effective. This opens a design space for corruption-aware training that has been underexplored in video generation.
GAN-based post-training at scale is viable for video. Prior work on GAN-enhanced diffusion distillation has been mostly in the image domain. Helios demonstrates that adversarial objectives can be integrated into a multi-model, multi-scale, 14B training pipeline without catastrophic instability, and that they provide genuine quality improvements beyond the teacher's ceiling (Table 5: removing Adversarial Post-Training drops Naturalness from 5 to 4). This invites exploration of stronger adversarial objectives and discriminator architectures specifically designed for video.

Follow-Up Research This Work Enables

1. Scaling the video continuation approach to other pretrained backbones and domains. The paper evaluates Helios exclusively on Wan-2.1-T2V-14B with general text-to-video prompts. A natural follow-up would apply the same three-stage training pipeline—Unified History Injection with Guidance Attention, Easy Anti-Drifting with Frame-Aware Corrupt, Deep Compression Flow with multi-scale distillation—to a different backbone architecture and domain. For example, initialize from a video prediction model trained on driving scenes (nuScenes, Waymo) or egocentric video (Ego4D), apply the Helios recipe, and measure whether the anti-drifting strategies transfer to domains with different motion statistics and scene dynamics. The key question: are the Frame-Aware Corrupt parameters ( $b_{\max} = 0.33$ , $a_{\max} = 1.7$ in Stage 3) domain-agnostic, or do they need calibration per backbone and data distribution? A strong follow-up would sweep corruption parameters on multiple domains and characterize the sensitivity surface, providing a transfer guide for practitioners.

2. Measuring and mitigating mode collapse in adversarially distilled video models. The absence of diversity evaluation is the most significant gap in the paper's experimental validation. A follow-up should compute standard diversity metrics (FID, IS, coverage, recall) for Helios-Distilled versus Helios-Base on HeliosBench, and systematically compare to DMD-only distillation (without the GAN objective) and to the DMD-only variants of Self-Forcing and Reward Forcing. The hypothesis generated by the paper is that the GAN objective improves Naturalness (5 vs. 4, Table 5) but may reduce diversity; a controlled measurement would quantify this tradeoff. If mode collapse is detected, mitigation strategies from the image GAN literature—gradient penalties beyond R1, multi-scale discriminators with independent objectives, diversity-sensitive GAN losses—could be tested. This is a high-impact follow-up because mode collapse could make Helios unusable for creative applications regardless of its quality scores.

3. Dynamic first-frame anchoring for narrative video with scene transitions. The First-Frame Anchor is effective for videos with consistent visual identity (Table 5: removing it drops Total by 0.96), but it imposes a fixed-identity constraint that conflicts with prompts requiring deliberate visual evolution. A follow-up should design and evaluate an adaptive anchoring mechanism: detect when the generated content has semantically diverged from the first frame (using ViCLIP similarity between the current generated frame and the anchor frame), and when divergence exceeds a threshold, update the anchor to a more recent stable frame. The system could maintain a small library of "candidate anchors" at scene boundaries inferred from optical flow discontinuities. Evaluation would use a custom benchmark of prompts requiring explicit scene transitions (e.g., "a timelapse from sunrise to sunset," "a journey from a forest to a beach to a city") and measure both anti-drifting and transition coherence with and without adaptive anchoring.

4. Quantifying the computational tradeoff between token compression and quality as a function of video content. The paper reports aggregate token compression numbers (8× for history, 2.29× for noisy context, Section 4.1) and shows a quality drop from Helios-Base (Total 6.57) to Helios-Mid (Total 6.05) in Table 4. But it does not characterize which types of videos suffer most from compression. Videos with rapid camera motion, fine textures, or many small moving objects likely require more tokens for short-term memory than videos with static backgrounds and slow motion. A follow-up should stratify HeliosBench by motion magnitude (using the Dynamic metric) and spatial complexity (using frequency-domain analysis of generated frames) and measure the quality gap between Base and Mid as a function of content characteristics. The practical output would be a content-adaptive compression policy: the model could dynamically adjust compression ratios based on real-time analysis of the generated video's motion and texture statistics, spending the token budget where it matters most. This would require adding lightweight, online content analysis modules to the inference pipeline.

5. Ablation on the number of pyramid stages and their resolution allocation. The paper sets $K=3$ stages and reports the token reduction factor without exploring the sensitivity of this choice. A follow-up should sweep $K \in \{2, 3, 4, 5\}$ and, for each $K$ , sweep the resolution allocation across stages (e.g., for $K=3$ , is $(H/4, H/2, H)$ optimal, or would $(H/2, H/2, H)$ work better?). The optimization criterion is the quality-vs-throughput tradeoff curve for Helios-Mid. Key question: does the observation that "early sampling steps are dominated by strong noise and thus mainly determine global structure" hold across all content types, or are there classes of videos where early high-resolution steps are necessary (e.g., videos with fine occlusions that must be established early to prevent structural artifacts)? A negative finding—that the optimal stage count varies substantially with content—would motivate content-adaptive stage scheduling, where the model selects $K$ and the resolution schedule per prompt based on estimated complexity. A positive finding—that $K=3$ is robustly optimal—would validate the paper's design choice and provide a practical guideline.

6. Training-cost amortization analysis for deployment decisions. The paper reports inference throughput (19.53 FPS, Table 3) and training configuration (Tables 1, 2) but does not compute total training cost or the break-even point where inference savings justify the training investment. A follow-up should: (a) estimate total GPU-hours for each stage using the reported steps, batch sizes, GPU counts, and per-step timing (extrapolated from Table 6 or measured directly); (b) compare against the training cost of Self-Forcing-based distillation for a 1.3B model (using reported hyperparameters from the cited papers); (c) compute, as a function of total inference volume and the cost ratio between H100-hours for training versus inference, the deployment volume at which Helios's 128× inference speedup over Wan 14B (0.33 FPS → 19.53 FPS in Table 3) amortizes the additional training cost. This would provide the first principled total-cost-of-ownership comparison between the two paradigms, and would be directly actionable for organizations deciding whether to adopt the Helios training recipe or continue with causal-masking-based approaches. The key unknown variables are Stage 3's per-step training time with four 14B models in GPU memory and the as-yet-unpublished inference throughput of Helios-Mid without distillation, which would determine whether Stage 3 is necessary for a given deployment's throughput requirements.

Practical Applications and Downstream Use Cases

1. Interactive creative tools with real-time visual feedback. The paper's headline number—19.53 FPS on a single H100 for a 14B model—directly enables a class of application where artists or designers iteratively refine text prompts and immediately see the resulting video. Prior to Helios, this workflow was impossible with large video models: Wan 2.1 14B at 0.33 FPS means a 5-second clip takes ~4 minutes, breaking the creative feedback loop. Helios-Distilled's 59× speedup over the same-sized Wan baseline makes sub-second-per-frame generation feasible: at 19.53 FPS and 3 sampling steps, the model generates a 5-second, 121-frame clip in roughly 6 seconds, which is within the tolerance for iterative creative work. The Interactive Interpolation mechanism (Section 3.5, Figure 23) further enables mid-generation prompt editing without jarring visual discontinuities—the artist can see the video evolving, change the prompt, and watch the content smoothly transition. The key deployment consideration from the paper: this requires an H100 GPU (throughput on other hardware is not characterized), and the first frame of any generation session will anchor the visual identity (First-Frame Anchor, Section 3.2.2), so artists wanting deliberate scene transitions would need to restart generation rather than continuing autoregressively.

2. Video continuation services at scale for user-generated content platforms. Platforms that allow users to upload short video clips and request AI-generated continuations (e.g., "extend this 3-second clip of my dog to 30 seconds") face a throughput-quality tradeoff. Self-Forcing-based 1.3B models (18–24 FPS, Table 4) are fast enough for real-time serving but produce lower-quality continuations (Total scores 5.00–5.80) with blurred details and limited motion complexity. Helios-Distilled achieves comparable speed (19.53 FPS) while matching the quality of 14B base models (Total 6.00–6.34, Table 3, comparable to Wan 2.1 14B at 6.15). The Representation Control module's automatic mode switching (Section 3.1.1)—treating the last frame of the uploaded clip as nonzero in $X_{\text{Hist}}$ to trigger I2V—eliminates the need for per-mode models or complex request routing. The infrastructure insight from Section 4 that Helios requires no model parallelism means these services could be deployed on single-GPU instances, simplifying cluster management and reducing per-request cost. The caveat from the paper's limitations: the model has only been tested to 1440 frames (60 seconds) on T2V; video continuation (V2V) quality at these durations is shown qualitatively (Figure 22) but not benchmarked quantitatively, so a platform would need to conduct its own V2V-specific evaluation at target durations.

3. Synthetic data generation for embodied AI and world model training. Training embodied AI systems (robotics policies, autonomous driving models, game-playing agents) requires vast amounts of diverse, temporally coherent video data with ground-truth action annotations. Current approaches rely on game engines (limited visual diversity) or recorded real-world data (expensive, privacy-constrained). A video continuation model running at 19.53 FPS on a single GPU could generate thousands of diverse, minute-scale training videos per day from text prompts describing agent behaviors, environments, and camera trajectories. The key advantage over prior approaches: Helios's 14B capacity captures complex motion and fine details that 1.3B models miss (the paper's explicit motivation for scaling beyond the existing real-time paradigm), and its anti-drifting mechanisms (Frame-Aware Corrupt + First-Frame Anchor, validated to 1440 frames in Table 4) maintain temporal coherence over durations relevant for long-horizon policy learning. The Adversarial Hierarchical Distillation with Adversarial Post-Training (Section 3.4.2) further improves Naturalness (Table 5, +1 point over non-adversarial variant), which is critical for sim-to-real transfer of policies trained on synthetic video. A deployment concern not addressed in the paper: the diversity of generated videos (see Section 6.4 in Limitations) is unmeasured; mode collapse in the distilled model could produce a dataset that covers only a narrow subset of the prompt-conditioned distribution, biasing policies trained on it.

4. Real-time visual generation for conversational AI and virtual assistants. As LLM-based conversational agents expand into multimodal output, the ability to generate video responses at conversational latencies becomes valuable. A user asks "show me what a golden retriever puppy playing in autumn leaves looks like," and the assistant generates and streams the video within seconds. Helios-Distilled's inference pipeline—starting from noise and producing frames at 19.53 FPS—makes this feasible for the first time with a large model. The Unified History Injection architecture supports the likely interaction pattern: the first request is T2V ( $X_{\text{Hist}}$ all zeros), and follow-up requests like "now show the puppy running toward the camera" use V2V ( $X_{\text{Hist}}$ contains the previously generated clip), maintaining visual continuity across conversational turns. The Interactive Interpolation mechanism (Equation 20) enables smooth transitions between user requests rather than abrupt cuts. The practical constraint from the paper's evaluation: the model is only tested on English prompts and general-domain content; domain-specific vocabularies (medical, technical, highly stylized artistic directions) would require evaluation. The First-Frame Anchor means that the visual identity established in the first response persists through the conversation; for a use case where the user says "now show a different dog," the model may struggle to shift identity without disabling the anchor and accepting the drift risk documented in Table 5 (Total drops from 6.47 to 5.51).