acceptodds
Under review as a conference paper at ICLR 2027

CtrlCache: Accelerating Interactive Video World Models with Control-Aware Caching

Abstract

Interactive video world models need to generate each video chunk efficiently while responding faithfully to user controls. Many systems use chunk-wise autoregressive generation with few-step denoising, but each chunk still requires several costly denoising iterations. Training-free caching can reduce this cost, yet existing policies make reuse decisions primarily from model-internal denoising dynamics and do not explicitly account for control transitions. Actually, interactive generation exposes a signal they do not use: the controls for a chunk arrive before it is denoised, so a schedule derived from them costs no forward pass. To this end, we analyze adjacent chunks under different control regimes and find that structural similarity drops around action changes, while low-frequency structure remains more persistent than high-frequency detail. Motivated by these observations, we propose , a training-free control-aware caching framework that adapts computation to the current control sequence. Specifically, the action-aware scheduling and refresh policy detects action changes across and within chunks and labels each chunk as initial, transition, turning, or steady. At one selected interior denoising step, initial and transition chunks retain full computation, while turning and steady chunks reuse the transformer residual from the most recent fully computed step in the same chunk. To exploit the persistence of low-frequency structure during steady interaction, we further introduce a frequency-mixed history prior guidance that incorporates complementary information from the preceding clean latent without an additional DiT forward pass. Evaluated on Matrix-Game 2.0 and LingBot-World v1/ v2, CtrlCache achieves 1.21×-1.41× DiT-backbone speedups without model retraining while improving WBench Overall scores over original inference across all three models.

Primary area:
generative models
Keywords:
cache, efficiency, interactive world models

Reviews

Among:
Shape:
1234this paper, Top 49%
Figure 1. Mean review rating of the reviewed papers at ICLR 2027. This paper averages 2.33 over 3 reviews, above 51% of the others.
Reviewer_3ojZOpenReview ↗
Rating
2
Confidence
3
Informativeness
3
Presentation
2
Soundness
2
Read review
Paper summary

This paper proposes CtrlCache, a training-free acceleration framework for interactive video world models. It uses incoming controls to determine whether to reuse transformer residuals at a selected intermediate denoising step. Initial and transition chunks retain full computation, while turning and steady chunks permit residual reuse within the current chunk. The method additionally introduces a frequency-mixed history prior, constructed from the preceding chunk’s last clean latent frame, to guide steady chunks. Experiments on Matrix-Game 2.0 and LingBot-World v1/v2 report 1.21× – 1.41× DiT-backbone speedups and improved WBench Overall scores.

Critical strengths
  • Practical motivation and inexpensive scheduling signal. Reducing inference cost remains important even for distilled, few-step world models. Incoming controls provide an available signal for allocating computation without additional backbone evaluations.

  • Simple integration with existing models. The method requires no retraining and retains full computation at the first and final denoising steps. Its evaluation across three backbones provides useful evidence of applicability beyond a single implementation.

  • Useful evaluation of history-guidance conditions. The ablations show that restricting history guidance to steady chunks performs better than extending it to turning or transition chunks. This supports the need to condition historical information transfer on the interaction regime.

Critical weaknesses
  • The quality–efficiency comparison does not establish an advantage at matched budgets. CtrlCache is slower than both caching baselines on every backbone in Table 1. Its higher quality is therefore compatible with spending more computation. Comparisons against budget-matched fixed or random refresh schedules, together with quality–latency curves, are needed to establish the value of action-aware allocation.

  • The methodological novelty is limited. Residual reuse is inherited from existing caching methods, while the scheduling policy primarily adds a binary control-transition gate at a backbone-specific denoising step. Although four control states are introduced, turning and steady chunks share the same reuse decision; their distinction only affects history guidance. The contribution is therefore an incremental scheduling and regularization design, whose advantage over existing adaptive caching approaches requires stronger evidence.

  • The experiments do not sufficiently isolate the proposed components. Table 2 lacks Original + History prior and TeaCache/EasyCache + the same prior. Consequently, the improved quality cannot be clearly attributed to the control-aware policy rather than an independently beneficial history regularizer. This distinction matters because naive residual reuse already accounts for approximately two-thirds of the complete method’s Overall improvement on LingBot-World v1.

  • The evidence for improved interactive performance remains incomplete. Reported speedups exclude KV-cache commit/update time and do not establish end-to-end action-to-frame latency. Furthermore, LingBot-World v2’s Interaction score decreases from 0.8389 to 0.8334 despite an improved Overall score. This warrants checking whether history guidance suppresses motion or delays scene evolution. The absence of confidence intervals and results across multiple seeds further limits the interpretation of small differences.

Questions for authors
  • Can the authors measure intra-chunk residual-reuse error separately for steady, turning, and transition chunks, and demonstrate that control transitions predict this error?

  • How do Original, TeaCache, and EasyCache perform when equipped with exactly the same history prior? How much improvement remains attributable specifically to action-aware scheduling?

  • What are the end-to-end latency and action-response latency, particularly for transition chunks? Does the method preserve camera-motion magnitude and timely appearance of newly visible regions?

  • What is the rationale for scaling the prior by wkw_k without restoring the current prediction’s weight? Can the authors separate frequency filtering from latent shrinkage and evaluate motion-aligned or amplitude-preserving alternatives?

7 comments

Thank you for the review. Here, we use MG2 = Matrix-Game 2.0, LB-v1/v2 = LingBot-World v1/v2.

W1. The quality–efficiency comparison.

(1) Comparisons against budget-matched fixed. Following your suggestion, we add the following experiment to keep the budget-matched fixed (same latency) on TeaCache (termed as TeaCache-M), EasyCache (termed as EasyCache-M) and our CtrlCache. To achieve the same budget, on top of TeaCache's and EasyCache's own published rules (Line 353), we added extra full computation so that every case has exactly CtrlCache's number of full DiT forwards. All methods here run on the same machine and are compared with the same Original outputs. The table shows that our CtrlCache keeps the best Quality, PSNR, SSIM and LPIPS on both MG2 and LB-v1.

Latency vs. OriginalLatency vs. CtrlCacheQualityPSNRSSIMLPIPS
MG2 TeaCache-M0.85×1.00×0.724414.010.32790.4894
MG2 EasyCache-M0.84×0.99×0.726413.260.30440.5044
MG2 CtrlCache0.85×1.00×0.737014.510.35040.4757
LB-v1 TeaCache-M0.85×1.00×0.804715.630.46590.3816
LB-v1 EasyCache-M0.84×0.99×0.805115.430.46140.3891
LB-v1 CtrlCache0.85×1.00×0.807317.270.50140.3451

Latency: DiT + KV-cache commit + VAE decoding per rollout, measured on one A100.

(2) Comparison against a random refresh schedule. Following your suggestion, we add an experiment on MG2 comparing our action-aware policy with a random refresh schedule. To ensure a fair comparison, both methods use the same number of fully computed chunks and the same number of reuse steps. As shown in the table below, the action-aware policy from Table 2 (without the history prior) outperforms the random refresh schedule on both quality and fidelity metrics.

MG2QualityPSNRSSIMLPIPS
Random refresh schedule0.724414.010.32790.4894
Action-aware policy (Table 2, no prior)0.731014.460.34860.4808

(3) Quality–latency curves. Since we use the type of control signal to decide when to do the reuse or full computation, there is no threshold for our CtrlCache to adjust the latency. Only the first and transition chunks are full computed. However, we could manually let turning or steady chunks conductfull computation to test the trade-off between quality and latency. In the following, we will not mention the first chunk for simplification. The table shows that computing more chunks in full does not improve Quality on MG2: CtrlCache has both the lowest latency and the highest Quality. We therefore keep the default setting (only transition chunks computed in full). We will add this quality–latency curve in the revised version.

Full computation chunksQualityLatency
All (Original)0.73601.00×
Transition + Turning + Steady0.72961.00×
Transition + Steady0.73060.96×
Transition + Turning0.73320.90×
Only Transition (Our CtrlCache)0.73700.85×
W2: Limited novelty.
  • To our best knowledge, CtrlCache is the first to use the incoming control sequence to decide both where to compute in full and how generated history is reused, rather than from feature changes or revisited views.
  • Unlike TeaCache and EasyCache, which decide reuse from feature or timestep-embedding changes, CtrlCache decides reuse and full computation from the control state of the incoming actions alone, without measuring features or relying on revisits.
  • Based on our analysis of control signals, we introduce a control-aware policy and a frequency-mixed history prior guidance to determine when to perform full denoising computation, when to reuse cached computation, and what information to carry forward from previous chunks. Although the method is straightforward, it is practical and works across multiple backbones. We believe it provides a basis for future work on more sophisticated ways to use control signals in few-step interactive world models.
  • Turning vs. steady chunks. On both turning and steady chunks, we use the reuse to save computation. However, applying the history prior guidance to turning chunks, the Overall drops (Table 2). The underlying reason is that during turning, the scene changes continuously (Line 464-470). We therefore use the same reuse policy for both chunk types and apply the history prior only to steady chunks.

W3: isolate the proposed components. Our history prior should be used when the action-aware policy has decided the action states. As in the main paper, we apply the history prior only on the steady chunks.

Thus, to add the advised experiments of Original + History prior and TeaCache + the same prior on MG2, we first record which chunks are steady using our CtrlCache, and then apply the history prior at the same steady chunks in both Original and TeaCache. Additionally, for TeaCache, we add the prior to TeaCache-M (W1), which computes as many full chunks as CtrlCache, so TeaCache-M + History prior differs from CtrlCache only in where the fully computed chunks go, without the budget difference.

The table shows that only adding the history prior yields no measurable gain for either Original or TeaCache. This suggests that the prior’s benefit depends on the action-aware policy, which determines when to reuse cached computation and when to perform full computation. In our experiments, the history prior improves performance only when combined with this policy.

MG2QualityCons.
Original0.73600.6838
Original + History prior (St.)0.72960.6839
TeaCache-M0.72440.6790
TeaCache-M + History prior (St.)0.72440.6764
Action-aware policy0.73100.6802
Action-aware policy + History prior (St.) (Full CtrlCache)0.73700.6867

W4: Evidence for improved interactive performance.

  • End-to-end and action-response latency: timing DiT, KV-cache commit and VAE decoding together, a chunk takes on average 0.74 s with CtrlCache vs. 0.87 s with the Original on MG2, and 7.0 s vs. 8.2 s on LB-v1. A chunk with a control change is computed in full and takes essentially the Original's time (MG2: 0.87 vs. 0.87 s; LB-v1: 8.4 vs 8.4 s); chunks with unchanged controls take 0.73 s on MG2 and 7.0 s on LB-v1 once the history context is filled.
  • Whether history guidance suppresses motion or delays scene evolution. No. (1) The history prior pulls steady chunks toward the preceding chunk, so it can slightly reduce motion, but its effect on Interaction is small and not one-directional (lower on MG2, higher on LB-v1, Table 2). The history prior is not used on turning or transition chunks, where the scene must change and most new content enters the view, so history cannot hold back newly visible regions. (2) The action change is a known/predefined signal, and the control state check incurs negligible overhead (~10e-6 ms) and requires no additional model forward pass. Thus, there is no delays for the scene evolution.
  • Confidence intervals and results across multiple seeds. We added two more seed results on LB-v2 Original and CtrlCache. CtrlCache's Interaction minus the Original's is +0.0068 (seed 43) and +0.0025 (seed 44), with a pooled paired 95% CI of [−0.004, +0.014], versus −0.0055 at seed 42, so the gap at seed 42 is within seed-to-seed small differences.

Q1. Can the authors measure intra-chunk residual-reuse error separately for steady, turning, and transition chunks, and demonstrate that control transitions predict this error? We use control changes not to predict the local reuse error but to decide which chunks to protect. On MG2, this error (relative residual change at the reuse step) is similar across states (transition 0.644, turning 0.644, steady 0.613), so local criteria such as TeaCache's and EasyCache's cannot single out these chunks; the control state can. Computing transition chunks in full keeps reuse errors out of them and thus limits error propagation: at equal compute, this gives higher fidelity than random placement (MG2: PSNR 14.46 vs 14.01 dB; W1).

Q2. How do Original, TeaCache, and EasyCache perform when equipped with exactly the same history prior? How much improvement remains attributable specifically to action-aware scheduling?

Please refer to W3. With the history prior held fixed, action-aware scheduling improves PSNR by 0.42 dB over TeaCache-M's uniform refresh at the same budget.

Q3-1. What are the end-to-end latency and action-response latency, particularly for transition chunks?

Please refer to W4. The end-to-end latency for a chunk is averagely 0.74 s with CtrlCache vs. 0.87 s with the Original on MG2, and 7.0 s vs. 8.2 s on LB-v1. The action-response latency for transition chunks is negligible (~10e-6 ms).

Q3-2. Does the method preserve camera-motion magnitude and timely appearance of newly visible regions?

Yes, CtrlCache closely preserves aggregate camera-motion magnitude relative to the Original. Using WBench’s navigation trajectory estimation method, we compute the CtrlCache-to-Original ratio on camera rotation and camera path length for each matched case and report the median over 40 cases. The table shows that the median ratios are within 3.7% of the Original across both backbones. These statistics summarize motion over the full clip, showing that the method preserve camera-motion magnitude.

BackboneCamera rotationCamera path length
MG20.984 (−1.6%)1.020 (+2.0%)
LB-v10.977 (−2.3%)1.037 (+3.7%)

Newly visible regions also appear on time. They typically appear at the same frame as in the Original, and the history prior does not delay them. To check this at the frame level, we use optical flow to locate when the camera motion and the newly visible regions respond to each of the 68 action changes on MG2, and measure how much CtrlCache lags behind the Original generated with the same seed. The median lag is 0 frames (24 fps) for both, and against the same policy without the prior, the median difference is 0 frames.

Q4-1. What is the rationale for scaling the prior by wkw_k without restoring the current prediction's weight? wkw_k is meant to reduce only how much history enters later frames (Eq. 6), not how much each frame relies on its own estimate. With z^←(1−λ)z^+λwk(zlow+αkzhigh)\hat{z}\leftarrow(1-\lambda)\hat{z}+\lambda w_k(z^{\mathrm{low}}+\alpha_k z^{\mathrm{high}}) (Eq. 7), λ=0.5\lambda=0.5 and wkw_k halving per frame (1, 0.5, 0.25, …), every frame keeps half of its own estimate, while the history it receives drops from 0.5 to 0.25 and 0.125. The weights then sum to less than 1 at later frames, but only at the first denoising step. For the following steps, including the fully computed final step, we re-estimate the latent, and restoring the weight brings no gain (see Q4-2 for more details).

Q4-2. Can the authors separate frequency filtering from latent shrinkage and evaluate motion-aligned or amplitude-preserving alternatives? Yes. The filtering helps, while the shrinkage does not hurt. Filtering is isolated in Table D.1(c), which varies only the frequency composition weight α\alpha (Eq. (6)). When α=1\alpha=1, there will be no filtering, i.e., reserving the preceding chunk’s last clean latent frame in full. It lowers Overall from 0.6786 to 0.6552 (MG2) and from 0.8127 to 0.7923 (LB-v1). Shrinkage is isolated by a new amplitude-preserving variant, z^←(1−λwk)z^+λwk(zlow+αkzhigh)\hat{z}\leftarrow(1-\lambda w_k)\hat{z}+\lambda w_k(z^{\mathrm{low}}+\alpha_k z^{\mathrm{high}}), which restores the weight and changes nothing else (MG2): it brings little gain (e.g., PSNR 14.43 vs 14.51 dB, Quality 0.7309 vs 0.7370). Motion-aligned priors need an extra flow or depth estimator, which adds cost to an acceleration method. We will add this discussion in the revised version.

Reviewer_SuV5OpenReview ↗
Rating
2
Confidence
4
Informativeness
2
Presentation
3
Soundness
2
Read review
Paper summary

CtrlCache uses control changes to decide when to reuse an intermediate denoising step's transformer residual, with a history prior applied during steady control. It requires no training and reports 1.21–1.41× DiT speedups with higher WBench Overall scores on three backbones.

Critical strengths
  1. A practical design. Using available control signals to guide reuse is inexpensive and fits the task. The method works across three backbones without retraining.

  2. Useful ablations. Table 2 separates residual reuse, the control policy, and the history prior. Applying the prior only during steady control works better than extending it to turns and transitions. The supplementary videos also provide helpful comparisons.

Critical weaknesses
  1. The comparison does not separate the policy from the compute budget. CtrlCache has higher Overall scores than TeaCache and EasyCache, but is slower on all three backbones. Table 2 supports the control policy, though enabling it also restores computation. A comparison at matched latency, or against a control-independent schedule with the same number of full steps, would help establish whether the policy offers a better speed–quality tradeoff. This is my main reservation.

  2. The implications for interaction latency are unclear. Control changes trigger full computation, precisely when a user expects a response to new input. The paper clearly labels its speedups as DiT-only, but mean time per case does not show response latency or its variability. The method may save computation during unchanged controls without making control changes respond faster. This limitation deserves discussion; the current results do not establish either improved responsiveness or noticeable latency fluctuations.

Questions for authors
  1. What thresholds and calibration settings were used for TeaCache and EasyCache on each few-step backbone?
  2. Were the hyperparameters in Table D.1 selected on cases separate from the 40 evaluation cases?
  3. In Figure 1, the rightmost images appear cooler in tone than the earlier ones in both Original and CtrlCache. Is this a lighting/viewpoint change or temporal drift in the backbone? Does caching or the history prior affect this behavior?
8 comments

Thank you for the detailed review. Here, we use MG2 = Matrix-Game 2.0, LB-v1/v2 = LingBot-World v1/v2.

W1 (main): policy vs. budget. We ran the suggested control-independent schedule with the same number of full steps: TeaCache and EasyCache keep their own rules and add control-independent full chunks until, in every case, their number of full DiT forwards equals CtrlCache's (termed as TeaCache-M / EasyCache-M). All methods here run on the same machine and are compared with the same Original outputs.

Latency vs. OriginalLatency vs. CtrlCacheQualityPSNRSSIMLPIPS
MG2 TeaCache-M0.85×1.00×0.724414.010.32790.4894
MG2 EasyCache-M0.84×0.99×0.726413.260.30440.5044
MG2 CtrlCache0.85×1.00×0.737014.510.35040.4757
LB-v1 TeaCache-M0.85×1.00×0.804715.630.46590.3816
LB-v1 EasyCache-M0.84×0.99×0.805115.430.46140.3891
LB-v1 CtrlCache0.85×1.00×0.807317.270.50140.3451

Latency: DiT + KV-cache commit + VAE decoding per rollout, measured on one A100. With the baselines equally fast or faster, CtrlCache still has higher fidelity to the original model's output and the best Quality on both backbones. The gain comes from where the policy places full computation: on MG2, placing the same number of full chunks by control state instead of control-independently already yields most of it, even without the history prior. We will add this comparison to the revised version.

W2: the implications for interaction latency. We measured per-chunk latency from denoising to decoded frames (DiT + KV commit + VAE decoding) on an A100.

  • Response latency of control changes (precisely when a user expects a response to new input). There is NO computational cost for the response to the control change. When control changes, the DiT will immediately receive the action signal, with no cost. Compared with the Original model, our CtrlCache only checks the type of control state C_n (Eq. 2). This action change is a known/predefined signal, and the control state check incurs negligible overhead (~10e-6 ms) and requires no additional model forward pass.
  • The method may save computation during unchanged controls without making control changes respond faster. Yes. We test the per-chunk latency separately on unchanged controls (steady and turning) and changed controls (transition), once the history context is filled. Chunks with unchanged controls averagely take 0.73 s on MG2 and 7.0 s on LB-v1, while chunks with changed controls averagely take 0.87 s on MG2 and 8.4 s on LB-v1.
    • Save computation largely under unchanged controls. In MG2, chunks with unchanged controls account for 91.4% of all MG2 chunks. Since CtrlCache processes these chunks much faster (0.73s vs. 0.87s), this is where most of the computational savings come from.
    • Keep the same computation under changed controls. When controls change, CtrlCache performs the same full computation as the original model (Line 221), with matching runtimes (MG2: 0.87 vs. 0.87 s, LB-v1: 8.4 vs. 8.4 s). It shows: (1) CtrlCache incurs negligible computational overhead (~10e-6 ms) when responding to a control change, and (2) it performs the same computation as the original model for chunks with changed controls without no additional cost. This is reasonable since full computation refreshes the cache as an action transition can substantially change the scene.
    • Moreover, a changed control (transition action) takes effect at the next chunk, so the user also waits for the current chunk in flight. The current chunk usually contains unchanged controls (account for 91.4% of all MG2 chunks), which will finish earlier using our CtrlCache. Thus, when looking through the whole denoising steps, a changed control could be reflected slightly earlier in our CtrlCache compared to that in the Original. Accumulatively, our CtrlCache is faster.
  • Either improved responsiveness or noticeable latency fluctuations of control changes. (1) Improved responsiveness. As noted above, handling a control change incurs negligible computational overhead. When the current chunk has unchanged controls, CtrlCache finishes denoising it sooner, allowing the next chunk with the changed control to be processed earlier. The chunk with the control change itself takes the same time to process as in the Original. (2) The latency fluctuations is stable and NOT noticeable. Chunks with a control change undergo full computation, matching the Original’s per-chunk latency (0.870 ± 0.002 s for MG2 and 8.43 ± 0.01 s for LB-v1). Chunks with unchanged controls reuse the cache and run faster (0.733 ± 0.028 s for MG2 and 6.99 ± 0.01 s for LB-v1). Both type of chunks have less than 4% latency variation (std / mean). The predefined control state is known before denoising begins and determines which computation path each chunk takes. This results in the negligible latency fluctuations, which is barely perceptible to users.

Q1: What thresholds and calibration settings were used for TeaCache and EasyCache on each few-step backbone?

  • Since TeaCache and EasyCache originally are applied on multi-step video gen models, they can not be used directly on few-step interactive world models. Thus we try our best to adapt them to the current setting for fairness.
  • TeaCache: We follow the original TeaCache paper, setting δ = 0.1, and Timestep as the Indicator.
  • EasyCache: If we use the original settings in the EasyCache paper (τ = 2.5–10%), its rule cannot skip any step here. Since our samplers have only 3–4 steps in total, based on the EasyCache rule, the only eligible step is the step 3. We thus calculated the estimated change on this step, and found that the change is about 100% on LB-v1, far above τ, since the fresh noise is added at every step in this sampler. Thus τ is meaningless in the current setting, and we simply apply its whole-step skip at a fixed step. For warm-up, we use the first step, since the original EasyCache uses 10%, where will be 0.3-0.4 steps here. So we upsample this warmup value.

Q2: Were the hyperparameters in Table D.1 selected on cases separate from the 40 evaluation cases?. No, Table D.1 uses the same 40 cases. LB-v2, however, is not part of Table D.1: it uses the prior setting selected on MG2 and LB-v1 unchanged, and CtrlCache still has the best Overall on LB-v2 and the largest fidelity margin of the three backbones (Table 1). This indicates that the hyperparameters are not fitted to the evaluation cases. In addition, on full 158 WBench navigation cases (refer to Xh91's W1), we also use the same hyperparameters, and achieve comparable performance.

Q3: Reason for the cool tone in Figure 1. Yes, this is because of the lighting change in the scene. Caching or the history prior does not affect this behavior. The underlying reason is that: (1) The backbone LB-v2 itself drifts slowly toward darker and cooler colors over long rollouts, which we observe in most of the Original's videos.

(2) The Figure 1 case is a sunset scene (prompt: "An East African savanna at sunset. ... Warm golden-hour light bathes the entire scene. ... a pair of warthogs graze in the fading light."). Caching and the history prior do not affect it: the Original, which uses neither, shows the same cooler tone (Figure 1, top row), and over all 40 LB-v2 cases, cached runs with or without the history prior (our CtrlCache) drift in color just like the Original.


Thanks for the authors’ detailed response. The controlled compute-budget comparisons support the method’s benefits.

Still, as clarified, the approach provides no acceleration during control changes (user interaction), which is the core scenario for video world models. While it speeds up when there is no user input, this yields limited improvements to interactive fluency.

Reviewer_Xh91OpenReview ↗
Rating
3
Confidence
2
Informativeness
2
Presentation
3
Soundness
2
Read review
Paper summary

This paper proposed CtrlCache, a training free framework for accelerate interactive video world models. The paper studied the similarity between the latents of the adjacent chunks under different control signals. Based on the observation, the paper proposed (1) action-aware scheduling and refresh policy, to decide when to reuse or refresh the cache, and (2) frequency-mixed history prior guidance, to provide historical prior of the frames. Experimental result show better performance on WBench.

Critical strengths
  1. The paper is well-motivated and the techniques are sound.
  2. The paper is well-structured and easy to follow
  3. The experiments show better performance on the generation quality.
Critical weaknesses

I am not an expert in diffusion model acceleration, I have only some minor concerns about the experiments.

  1. The evaluation is conducted on the 40 cases sampled from WBench navigation split, as described in Appendix Sec. C. The test data seems very limited, compared to video generation benchmarks (which typically have hundreds of test cases).
  2. In table 1, the proposed method generally achieves better generation quality, but with lower efficiency. It is doubtful that if the higher quality is partly entangled with a less aggressive acceleration setting, instead of the proposed framework design.
Questions for authors

Please see weaknesses.

1 comment

Thank you for the positive assessment. In the following, we use MG2 = Matrix-Game 2.0, LB-v1/v2 = LingBot-World v1/v2.

W1: 40 test cases. Our 40 cases are a stratified random sample (seed 42) of the 158 WBench navigation cases, covering all six trajectory types in proportion and both first- and third-person views. We also evaluated all 158 navigation cases on LB-v1 as follows.

LB-v1, 158 casesQualityCons.Inter.SettingPhysicsOverallPSNRSSIMLPIPSSpeedup
Original (official leaderboard)0.7940.8490.7920.7790.6570.774–––1.00×
CtrlCache (original)0.8000.8600.7930.7950.7020.79016.370.46490.36441.26×
Original (new)0.7940.8590.8030.7660.6140.767–––1.00×
TeaCache (new)0.7970.8650.8100.7590.6130.76915.060.43080.40181.30×
EasyCache (new)0.7980.8630.8060.7490.6140.76615.040.43070.40281.31×
CtrlCache (new)0.8000.8600.7930.7650.6100.76616.370.46490.36441.26×

"Original": official WBench leaderboard (evaluated by the benchmark authors). "Speedups" (DiT only) are those of Table 1.

Note that, the official WBench leaderboard uses <doubao-seed-2-0-lite-260215> as its default VLM judge (denoted “original”) for VLM-based metrics, including Setting, and Physics. However, Volcengine discontinued this model on 2026-10-22 14:00 (UTC+8), and we could not use this model for evaluation after then. We therefore compute the VLM-based metrics using Volcengine’s replacement model, <doubao-seed-2-0-lite-260428>(denoted “new”).

W2: if the higher quality is partly entangled with a less aggressive acceleration setting, instead of the proposed framework design? No. The higher quality is from our proposed framework design. We tested this directly: on top of TeaCache's and EasyCache's own rules, we added extra full computation so that every case has exactly CtrlCache's number of full DiT forwards (TeaCache-M / EasyCache-M), which makes the latency/acceleration setting the same in all three methods. All methods here run on the same machine and are compared with the same Original outputs.

Latency vs. OriginalLatency vs. CtrlCacheQualityPSNRSSIMLPIPS
MG2 TeaCache-M0.85×1.00×0.724414.010.32790.4894
MG2 EasyCache-M0.84×0.99×0.726413.260.30440.5044
MG2 CtrlCache0.85×1.00×0.737014.510.35040.4757
LB-v1 TeaCache-M0.85×1.00×0.804715.630.46590.3816
LB-v1 EasyCache-M0.84×0.99×0.805115.430.46140.3891
LB-v1 CtrlCache0.85×1.00×0.807317.270.50140.3451

Latency: DiT + KV-cache commit + VAE decoding per rollout, measured on one A100.

With the baselines equally fast or faster, CtrlCache still has higher fidelity to the original model's output. We will add this comparison to the revised version.


Comments on the paper

1 comment
AuthorsOpenReview ↗

General Comment

We thank all three reviewers for their constructive feedback and for recognizing CtrlCache as a practical, training-free design that uses available control signals to guide reuse (SuV5, 3ojZ), with a well-motivated method that is easy to follow (Xh91), applicability across three backbones (SuV5, 3ojZ), and useful ablations (SuV5, 3ojZ). During the discussion period, we added budget-matched comparisons, a full-benchmark evaluation, per-chunk latency measurements, and further analyses, summarized below (MG2 = Matrix-Game 2.0, LB-v1/v2 = LingBot-World v1/v2).

1. Policy vs. Budget (Xh91's W2, SuV5's W1, 3ojZ's W1)

  • Budget-matched baselines (Xh91's W2). TeaCache and EasyCache keep their own rules and add control-independent full chunks until every case has exactly CtrlCache's number of full DiT forwards (TeaCache-M, EasyCache-M). With the baselines equally fast or faster (0.85× and 0.84× of the Original's latency, vs. 0.85× for CtrlCache, whose DiT-only speedup is 1.41× on MG2 and 1.26× on LB-v1), CtrlCache has the best Quality and the highest fidelity on both MG2 and LB-v1, e.g., PSNR 14.51 vs. 14.01/13.26 dB on MG2 and 17.27 vs. 15.63/15.43 dB on LB-v1. Reviewer SuV5 noted that these comparisons support the method's benefits.
  • Control-aware allocation (SuV5's W1). On MG2, with the same numbers of full chunks and reuse steps, allocating full computation by control state outperforms a control-independent refresh schedule even without the history prior (Quality 0.7310 vs. 0.7244, PSNR 14.46 vs. 14.01 dB).
  • Quality–latency trade-off (3ojZ's W1). Also computing turning or steady chunks in full raises the latency from 0.85× to 0.90×–1.00× of the Original with lower Quality (0.7370->0.7296), so CtrlCache only computes transition chunks in full.

2. Interaction Latency (SuV5's W2, 3ojZ's W4, Q3)

  • User input in every chunk with negligible response cost (SuV5's W2 and 3ojZ's Q3). Every chunk carries a user command. Chunks in which the user keeps holding the same command make up 91% of all chunks on MG2 and 86% on LB-v1, and CtrlCache accelerates all of them, so the speedup applies during active interaction.
  • Per-chunk latency (SuV5's W2). Measured from denoising to decoded frames (DiT + KV-cache commit + VAE decoding) once the history context is filled, held-command chunks take 0.73 s on MG2 and 7.0 s on LB-v1, while chunks where the command changes take 0.87 s and 8.4 s, the same as the Original. Both vary by less than 4% (std / mean), and the control state check incurs negligible overhead (~10e-6 ms) and requires no additional model forward pass.

3. Additional Experiments

ExperimentReviewerKey outcome
All 158 WBench navigation cases (LB-v1)Xh91's W1, SuV5's Q2Same hyperparameters, comparable WBench scores, and the highest fidelity among caching methods (PSNR 16.37 vs. 15.06/15.04 dB)
Seeds and confidence intervals3ojZ's W4Two more seeds on LB-v2 with a pooled paired 95% CI, and paired bootstrap 95% CIs over the 40 cases for the fidelity gains over TeaCache-M and EasyCache-M (PSNR +0.50 to +1.83 dB, better in 29–37 of 40 cases)
History prior on other methods3ojZ's W3, Q2No measurable gain for the Original or TeaCache-M, while on top of the action-aware policy it raises Quality from 0.7310 to 0.7370 on MG2
Reuse error by control state3ojZ's Q1Similar across states (0.613–0.644 on MG2), so local criteria cannot single out transition chunks while the control state can
Camera motion and scene evolution3ojZ's Q3Median ratio to the Original of 0.977–0.984 for rotation and 1.020–1.037 for path length, and newly visible regions appear on time
Prior design3ojZ's Q4Frequency filtering helps and the shrinkage does not hurt (an amplitude-preserving variant brings little gain)

4. Clarifications and Planned Revisions

  • We clarified the novelty relative to feature-based caching (3ojZ W2), the TeaCache and EasyCache settings on few-step backbones (SuV5 Q1), the hyperparameter selection and its transfer to LB-v2 (SuV5 Q2), and the cool tone in Figure 1, which comes from the lighting change in the scene rather than from caching or the history prior (SuV5 Q3).
  • In the revised version, we will add the experiments above, define the control states explicitly (a held command vs. a command change), and further refine the Figure 3.

From OpenReview, CC BY 4.0. Authors as signed there; shown unedited.

Related papers

Loading the map…

Discussion (0)

Sign in to comment.