Technical Summary: TempAct

Problem Statement

Autoregressive (AR) video diffusion models enable low-latency, chunk-wise streaming generation by synthesizing videos sequentially using cached visual context. However, this formulation introduces significant challenges in temporal instruction following:

1. Temporal Confusion: When conditioned on a single global prompt, the model often fails to determine which sub-event corresponds to the current chunk. This leads to "collapsed" or blurred event orders (e.g., a dog holding a ball before it has even pounced).
2. Step-Prompt Transition Failures: Naively switching to step-wise prompts (where each chunk has a specific sub-prompt) shifts the difficulty to handling prompt transitions. AR executors often exhibit delayed reactions, blend adjacent step semantics, or propagate errors from earlier chunks into later ones.
3. Limitations of Existing Training: Supervised Fine-Tuning (SFT) suffers from exposure bias (training on clean teacher-forced histories but inferring on imperfect rollouts). Rollout-based distillation methods (e.g., DMD) optimize low-level denoising or teacher-distribution matching rather than explicitly enforcing action ordering or prompt-transition correctness.

Methodology: TempAct

The authors propose TempAct, a Planner-Executor Reinforcement Learning (RL) framework designed to jointly optimize temporal decomposition and step-conditioned execution.

1. Hierarchical Planner-Executor Pipeline

• LLM Planner ($\pi_\phi$): Instead of a fixed preprocessing module, the planner is an LLM that explores span-aware temporal decompositions. Given a global instruction, it samples a group of candidate plans, where each plan breaks the instruction into step prompts with specific temporal spans (e.g., $L$ latent frames). The planner also rewrites subgoals with explicit objects, actions, and state constraints.
• AR Diffusion Executor ($p_\theta$): The executor generates video chunks autoregressively. Crucially, it uses smoothed prompts ($\tilde{s}_j = \text{Smooth}(s_j, s_{j+1})$) to expose the model to both the current and upcoming subgoals, reducing abrupt semantic shifts during transitions.

2. Hierarchical Group Exploration

To enable effective credit assignment, TempAct employs a nested group structure:

• Planning Groups: For a global prompt, the planner samples $M$ candidate plans.
• Execution Groups: For each candidate plan, the executor generates a shared context up to the transition point, then samples $N$ distinct continuations from that shared context.
• Credit Assignment:
  • Plan-level: Comparisons across the $M$ planning groups reward decompositions that lead to better long-horizon temporal outcomes.
  • Executor-level: Comparisons within the $N$ execution groups (sharing the same context) isolate the quality of the prompt-switch behavior from variations in preceding history.

3. Joint Reinforcement Learning Objective

The framework optimizes both components using Group Relative Policy Optimization (GRPO) variants:

• Planner Optimization: Updated via Group Sequence Policy Optimization (GSPO). The advantage is calculated based on plan-level rewards (quality and executability) and video-level temporal following scores.
• Executor Optimization: Updated via Flow-GRPO. The update is applied specifically to the first chunk after a prompt switch (the transition span). This focuses the learning signal on the immediate execution of the new subgoal under imperfect autoregressive context, rather than the entire future trajectory.

4. Multi-Level Reward Design

• Planner Rewards:
  • Plan Quality: Evaluated by an LLM (Qwen3-8B) on faithfulness, coverage, temporal coherence, and hallucination avoidance.
  • Temporal-Following: Evaluated by a VLM (Qwen3-VL-8B) on the generated video, assessing physical consistency, visual consistency, and event ordering.
• Executor Rewards:
  • Local Step-Following: A VLM evaluates the first transition chunk to verify if the specific subgoal (subjects, motion, dynamics) was realized correctly.
  • Aesthetic Regularization: A score (PickScore) ensures semantic optimization does not degrade visual quality.

Key Contributions

1. Planner-Executor Framework: A novel architecture that decouples temporal planning (event ordering) from execution (visual realization), allowing the system to learn which temporal plans are executable by the video model.
2. Hierarchical Group Exploration: A mechanism that nests execution groups under planning groups, enabling aligned credit assignment for both long-horizon temporal outcomes and local prompt-switch behaviors.
3. Targeted RL Optimization: The use of GSPO for the planner and Flow-GRPO for the executor (specifically on transition chunks) directly addresses exposure bias and prompt-transition errors without relying solely on distillation.
4. Span-Aware Prompting: The introduction of smoothed, span-aware step prompts that mitigate the semantic discontinuity often found in hard prompt switching.

Experimental Results

The paper evaluates TempAct on Self-Forcing and LongLive autoregressive backbones using a dataset of 5,000 temporally structured instructions.

• Metrics: The primary metric is the Temporal-Following Score, measuring adherence to the intended event sequence.
• Performance: TempAct demonstrates consistent improvements in temporal consistency compared to single-prompt baselines and step-prompt baselines, both in-domain and out-of-domain (evaluated by VLMs and human judges).
• Visual Quality: The method preserves overall visual quality and aesthetic scores, indicating that the RL optimization does not compromise generation fidelity.
• Training Dynamics: The reward curves show that the hierarchical optimization provides effective learning signals for temporal plausibility.

Significance and Claims

The paper claims that TempAct offers a new perspective on long-horizon temporal plausibility in autoregressive video generation. By moving beyond low-level denoising optimization or simple distribution matching, TempAct explicitly enforces action ordering and prompt-transition correctness. The authors position this as a necessary step for deploying AR video models in interactive applications where low-latency streaming must be coupled with strict adherence to complex, multi-stage temporal instructions. The work suggests that jointly optimizing the "what" (planning) and the "how" (execution) via hierarchical RL is a more robust solution to temporal confusion than previous SFT or distillation-only approaches.