MotionCache: Motion-Aware Video Caching

• MotionCache is a training-free, motion-aware caching framework that leverages token-level update strategies based on dynamic and static regions.
• It employs a dual-stage coarse-to-fine inference schedule with an initial warm-up phase followed by token-specific reuse to balance speed and quality.
• By integrating into autoregressive video generators like SkyReels-V2 and MAGI-1, the method achieves speedups up to 6.28× with minimal quality degradation.

MotionCache is a training-free, motion-aware caching framework for accelerating autoregressive video generation. It is designed for iterative denoising pipelines in models such as SkyReels-V2 and MAGI-1, and is motivated by the observation that video tokens are not equally redundant: pixels or tokens in high-motion regions require more denoising updates, whereas static or background regions can safely reuse cached residuals for longer intervals. The method therefore replaces coarse chunk-level reuse with a coarse-to-fine schedule that begins with a warm-up phase for semantic stabilization and then switches to motion-weighted token-wise cache reuse, yielding reported speedups of 6.28× on SkyReels-V2 and 1.64× on MAGI-1 while preserving generation quality with only very small VBench degradation (Xu et al., 3 May 2026).

1. Problem formulation and design objective

MotionCache is situated in the setting of autoregressive video generators based on the Causal Diffusion-Forcing (CDF) framework. In this setting, a long video is partitioned into chunks,

$$\{\mathbf{X}^1, \dots, \mathbf{X}^k\}, \quad \mathbf{X}^i \in \mathbb{R}^{F \times H \times W \times C},$$

where each chunk contains $F$ latent frames with spatial size $H \times W$ and channel dimension $C$. Denoising follows a flow-matching or Euler update,

$$\mathbf{X}_{t-1}^i = \mathbf{X}_t^i + v_\theta(\mathbf{X}_t^i, t, c)\cdot \Delta t.$$

For cache reuse, the paper writes the denoising computation in residual form,

$$\mathcal{R}_t^i = v_\theta(\mathbf{X}_t^i, t, c) - \mathbf{X}_t^i.$$

The central problem is that iterative denoising remains expensive even when autoregressive chunking makes memory use scalable. Prior reuse strategies are described as too coarse for this setting. Layer-level caching is accurate but memory-heavy; step-level caching is lightweight but less precise; and in the autoregressive setting the closest baseline makes an all-or-nothing decision at the chunk level, treating the entire chunk as either computed or skipped. MotionCache was proposed to address this granularity mismatch by recognizing that motion within a chunk is spatially heterogeneous: some regions evolve rapidly, while others remain stable over multiple denoising steps (Xu et al., 3 May 2026).

A common misconception is that cache reuse in autoregressive video generation can be controlled adequately by a single global distance metric. MotionCache argues against this by noting that chunk-level criteria such as

$$L1_{rel}(\mathbf{X}^i, t) = \frac{\|\mathbf{X}_t^i - \mathbf{X}_{t+1}^i\|_1}{\|\mathbf{X}_{t+1}^i\|_1}$$

cannot capture token-level residual instability. The method’s stated objective is therefore not merely to skip more denoising steps, but to distribute recomputation preferentially toward dynamic tokens and away from static ones.

2. Residual instability and motion as a proxy

The paper’s theoretical basis is the Residual Inconsistency Principle. If computation is skipped at timestep $t-1$ and the residual $\mathcal{R}_t^i$ is reused, the local approximation error is

$$\epsilon_{t-1}^i = \Delta t \cdot \| \mathcal{R}_{t-1}^i - \mathcal{R}_{t}^i \|_2.$$

This formalizes the claim that cache error is strictly proportional to the change in the true residual between adjacent steps. Under this view, caching is safe only where residuals are temporally stable (Xu et al., 3 May 2026).

MotionCache then connects residual instability to motion. Under a Lipschitz-style assumption, the residual difference is bounded by the intra-chunk frame difference,

$F$0

This makes frame-to-frame latent difference a lightweight proxy for token motion and, by extension, for residual instability. The paper reports empirical support for this proxy by ranking tokens according to frame-difference importance versus true residual difference and obtaining NDCG > 0.94 across denoising timesteps.

This suggests a specific interpretation of “motion-aware” in MotionCache. The method does not depend on an explicit optical-flow estimator or a learned motion head. Instead, it uses adjacent-frame latent differences inside the denoising process itself as the control signal for reuse. That design keeps the mechanism lightweight while retaining a direct link to the paper’s cache-error argument.

3. Coarse-to-fine inference schedule

MotionCache is described as a dual-stage coarse-to-fine inference schedule with motion-weighted token reuse. The first stage is a warm-up or coarse stage. Early in generation, global semantics are unstable, so fine-grained token skipping may damage structural coherence. The method therefore begins with a chunk-wise full-update phase in which the decision is binary for the entire chunk,

$F$1

The paper states that this phase lasts for $F$2 full computations. It also states that the first $F$3 timesteps are a global warm-up phase where cache reuse is disabled, following the chunk-level baseline, in order to ensure trajectory stability (Xu et al., 3 May 2026).

After warm-up, MotionCache switches to a fine-grained token-wise stage. For each frame $F$4 in chunk $F$5, it defines a motion importance score using adjacent-frame latent differences from timestep $F$6,

$F$7

This definition handles ordinary frames, the first frame of a chunk, and the first frame of the entire video separately.

The raw motion importance is converted to a normalized weight map,

$F$8

with normalization performed independently per frame. The floor $F$9 prevents even nominally static tokens from receiving zero update probability. This is a significant design choice: static regions are updated less often, not never.

The method then maintains a per-token accumulator $H \times W$0. At each timestep it first computes the global chunk update magnitude,

$H \times W$1

and updates the token accumulators by

$H \times W$2

A token is recomputed when

$H \times W$3

after which its accumulator is reset to zero.

Operationally, this means that high-motion tokens, for which $H \times W$4, accumulate budget rapidly and are refreshed often, whereas low-motion tokens, for which $H \times W$5, accumulate more slowly and can reuse cached computation across more denoising steps. The system is therefore sparse in a token-selective way rather than in a chunk-selective way.

4. Model integration and implementation characteristics

MotionCache is evaluated on SkyReels-V2-1.3B and MAGI-1-4.5B-distill, and the paper explicitly notes that these models differ in execution granularity. MAGI-1 operates at the inter-chunk level with a sliding window, whereas SkyReels-V2 uses a hierarchical intra-chunk strategy with staggered block inference and asynchronous noise levels. MotionCache is adapted to both by applying motion-aware token masking within each model’s execution structure (Xu et al., 3 May 2026).

The reported model-specific settings are concise but informative. For SkyReels-V2, the paper uses $H \times W$6, $H \times W$7, and warm-up $H \times W$8. For MAGI-1, it uses $H \times W$9, $C$0, and warm-up $C$1. These settings indicate that the method is not entirely parameter-free. The paper also notes that performance depends on $C$2 and $C$3, and that adaptation to different architectures is not completely plug-and-play.

The experimental setup reports the following generation conditions. MAGI-1 is evaluated at 720p, with 7 chunks, 24 frames per chunk, and 24 FPS. SkyReels-V2 is evaluated at 540p, with 2 chunks, 97 frames per chunk, and 24 FPS. Implementation is in PyTorch, and experiments are run on NVIDIA A800 80GB GPUs. The reported metrics are VBench-long (referred to as VBench), PSNR, SSIM, LPIPS, PFLOPs, latency, and speedup.

A further misconception that the paper effectively rejects is that motion-aware caching can be applied from the start of denoising with no semantic cost. MotionCache explicitly retains a warm-up interval before sparse token-wise reuse. This suggests that the method treats early denoising as a structure-formation regime in which conservative computation remains necessary.

5. Empirical performance and ablation findings

The headline quantitative results are summarized below.

Model	Variant	Reported outcome
SkyReels-V2	MotionCache-fast	7.26×, latency 212s, VBench 82.75%, PSNR 21.78, SSIM 0.8723, LPIPS 0.1478
SkyReels-V2	MotionCache-slow	6.28×, latency 245s, VBench 82.84%, PSNR 23.46, SSIM 0.9093, LPIPS 0.0875
MAGI-1	MotionCache-fast	2.07×, latency 733s, VBench 74.59%, PSNR 17.70, SSIM 0.5600, LPIPS 0.4861
MAGI-1	MotionCache-slow	1.64×, latency 925s, VBench 77.25%, PSNR 19.71, SSIM 0.7231, LPIPS 0.2510

For context, the unaccelerated baselines are reported as 1×, 1540s, 83.84% VBench for SkyReels-V2 and 1×, 1520s, 77.26% VBench for MAGI-1. The abstract condenses these results as 6.28× and 1.64× speedups with VBench reductions of $C$4 and $C$5 respectively (Xu et al., 3 May 2026).

The paper interprets MotionCache as providing the best speed-quality trade-off among the compared methods. On SkyReels-V2, it achieves stronger speedups while improving PSNR relative to the chunk-level binary skipping baseline. On MAGI-1, it preserves quality much better than the timestep- and chunk-level baselines at comparable or better acceleration. This suggests that the token-wise motion policy is most valuable when quality degradation from coarse reuse would otherwise concentrate in dynamic regions.

The ablations clarify the role of the two principal hyperparameters. For the soft-mapping floor $C$6, the paper sweeps from 0.0 to 1.0. It reports that $C$7 disables forced updates for static areas and hurts quality badly, whereas larger $C$8 improves background preservation but reduces selectivity. On SkyReels-V2, the reported example moves from PSNR 20.22, SSIM 0.7944, LPIPS 0.5853 at $C$9 to PSNR 23.46, SSIM 0.9093, LPIPS 0.0875 at $$\mathbf{X}_{t-1}^i = \mathbf{X}_t^i + v_\theta(\mathbf{X}_t^i, t, c)\cdot \Delta t.$$0. The paper states that the best trade-off is around $$\mathbf{X}_{t-1}^i = \mathbf{X}_t^i + v_\theta(\mathbf{X}_t^i, t, c)\cdot \Delta t.$$1 or $$\mathbf{X}_{t-1}^i = \mathbf{X}_t^i + v_\theta(\mathbf{X}_t^i, t, c)\cdot \Delta t.$$2 depending on the reported table; the implementation section uses 0.5, while the main ablation highlights 0.6 as best on the reported metric set.

For the coarse-stage duration $$\mathbf{X}_{t-1}^i = \mathbf{X}_t^i + v_\theta(\mathbf{X}_t^i, t, c)\cdot \Delta t.$$3, the paper sweeps from 0 to 17. It reports that $$\mathbf{X}_{t-1}^i = \mathbf{X}_t^i + v_\theta(\mathbf{X}_t^i, t, c)\cdot \Delta t.$$4 is worst because token-wise skipping begins too early, that performance improves up to about 6, and that gains then saturate. The reported example on SkyReels-V2 changes from PSNR 20.79, SSIM 0.8636, LPIPS 0.1963 at $$\mathbf{X}_{t-1}^i = \mathbf{X}_t^i + v_\theta(\mathbf{X}_t^i, t, c)\cdot \Delta t.$$5 to PSNR 23.46, SSIM 0.9093, LPIPS 0.0875 at $$\mathbf{X}_{t-1}^i = \mathbf{X}_t^i + v_\theta(\mathbf{X}_t^i, t, c)\cdot \Delta t.$$6. Very large $$\mathbf{X}_{t-1}^i = \mathbf{X}_t^i + v_\theta(\mathbf{X}_t^i, t, c)\cdot \Delta t.$$7 values push the method toward the coarse chunk-level regime it was designed to improve upon.

6. Position within the caching literature and scope of applicability

MotionCache belongs to a broader class of training-free cache-reuse methods for generative and sequential systems, but its defining niche is precise. It focuses on autoregressive video diffusion models, uses intra-chunk frame differences as a proxy for residual instability, and makes token-wise rather than chunk-wise reuse decisions (Xu et al., 3 May 2026).

This differs from several adjacent lines of work. WorldCache addresses DiT-based video world models and replaces zero-order hold reuse with motion-adaptive thresholds, saliency-weighted drift estimation, blending, warping, and phase-aware threshold scheduling (Nawaz et al., 23 Mar 2026). C$$\mathbf{X}_{t-1}^i = \mathbf{X}_t^i + v_\theta(\mathbf{X}_t^i, t, c)\cdot \Delta t.$$8ache targets World Action Models and exploits redundancy across inference chunks at the same denoising step, rather than within-chunk motion heterogeneity (Zhao et al., 8 Jun 2026). X-Slim is a unified caching framework for diffusion models that spans timesteps, Transformer blocks, and tokens under a dual-threshold push-then-polish controller (Wen et al., 14 Dec 2025). OmniCache takes a trajectory-oriented view of diffusion transformer sampling and selects reuse points by global curvature while filtering cache-induced noise (Chu et al., 22 Aug 2025). Outside generative modeling, FluxShard uses codec-level motion vectors to manage feature-cache reuse at motion-region granularity in mobile edge video analytics (Guan et al., 7 May 2026).

These comparisons help delimit what MotionCache is and is not. It is not a general-purpose caching controller across all reuse granularities, as in X-Slim. It is not a world-model feature approximation framework with saliency-weighted drift and warping, as in WorldCache. It is also not a cross-chunk residual cache, as in C$$\mathbf{X}_{t-1}^i = \mathbf{X}_t^i + v_\theta(\mathbf{X}_t^i, t, c)\cdot \Delta t.$$9ache. Its contribution is narrower and more specific: within autoregressive video generation, it maps local motion heterogeneity to token-level update frequency.

The paper’s limitations are correspondingly specific. Performance depends on $$\mathcal{R}_t^i = v_\theta(\mathbf{X}_t^i, t, c) - \mathbf{X}_t^i.$$0 and $$\mathcal{R}_t^i = v_\theta(\mathbf{X}_t^i, t, c) - \mathbf{X}_t^i.$$1; the method requires a warm-up stage and is therefore not sparse from the beginning of denoising; the motion signal is a proxy based on frame difference rather than direct residual measurement; and integration must be adapted to the execution structure of each model. A plausible implication is that MotionCache is most effective when the latent motion field is informative enough to distinguish dynamic from static regions, and when the video generator exposes a chunked denoising process in which token-level masking can be inserted without rewriting the model’s overall execution schedule.