A row of dominoes stands in a line. Knock over the first one and the next falls, then the next, on down the line. But ask a video generation model to continue the scene and something strange happens. Some models render the middle pieces slumping straight down in place, with no direction at all. The appearance follows plausibly from the frame right before it, yet the model has missed which way the fall is spreading.
That is exactly where "Looking Ahead," a paper from Nanjing University, Tencent ARC Lab, and Zhejiang University, takes aim. The method the authors propose, Future Chunk Prediction (FCP), trains the model to predict a more distant part of the clip without showing it the frames in between. The mechanism is switched on only during training and removed at inference. What the authors report gaining from it is physical plausibility — how well a generated video moves in line with real-world physics.
Start with "autoregressive video generation." Instead of producing a long video in one shot, you split the video into chunks of a few frames each. Then you look at the previous chunk to generate the next one, look at that result to generate the one after, and keep stitching them together. This lets you extend a video endlessly, like a stream, and it forms the basis of interactive simulation and of world models — models that mimic, through generation, how the world behaves.
Standard training works like this. When generating the next chunk, instead of feeding in the earlier frames the model produced itself, you condition it on the earlier frames as actually filmed (the ground truth — the corresponding chunk of the real video).
Here a trap opens up. In video, neighboring chunks look and move very much alike. There is a lot of overlapping information, which is called temporal redundancy. So the model can render the current chunk by all but copying the appearance of the chunk right before it — without ever having to think about how things will unfold. The paper calls this easy path, leaning on immediate visual continuity, a "shortcut." Settling into that shortcut takes the pressure off learning the scene changes that actually matter, and the limits show up when the model has to carry a sequence forward over a long stretch.
The fix is to move the prediction target well away from the observed past. The very next scene can be gotten roughly right just by copying the appearance of the previous one. But a distant scene several chunks ahead cannot. It only works out if you also get which direction an object moves and how fast, and how the relationships between objects shift.
The goal here is not to make the model predict the distant future exactly. The further out you go, the more branches the future can split into, so pinning it to a single right answer is hard to begin with. The aim lies elsewhere: in the effort of trying to predict a distant scene, the model's own body is trained to carry the information of "how objects move." Copying appearances can't reduce the error on a distant scene, so the model has no choice but to learn how motion unfolds.
FCP leaves the standard training objective in place and adds a single auxiliary objective on top. Where standard training predicts the very next chunk from the observed past, FCP uses that same past but hides the intermediate chunks and predicts a distant chunk several steps ahead (offset k — the value that sets how many chunks ahead to predict). In effect, it takes away the cheat sheet of the middle scene. Where existing approaches change the generation process itself or how past information is handled, the only thing FCP touches is what the model is asked to predict — the training objective.
Existing work on this problem falls broadly into two streams. One fixes the quality of the long video (rollout) a model generates by continuing on its own — turning a bidirectional model into a causal generator that is fast because it only runs a few steps at a time, exposing the model to its own generated past, or examining how teacher guidance and student generation mesh. The other manages the past context, trading off long-range consistency against memory cost via active windows, caches, global anchors, selective retrieval, and cache compression. FCP complements these two rather than competing with them. It does not dictate the rollout method or the inference-time context management; it simply adds future-chunk supervision on top of standard training.
From the representation-alignment family it differs in where the supervision signal comes from. That line accelerates and improves training by aligning a diffusion model's intermediate features with the representations of an external vision model, but it depends on an external pretrained encoder, which can become a bottleneck when scaling to large video. FCP draws supervision from the future chunks of the training videos themselves, so it needs no extra vision model and has a scaling path where the supervision grows as the data grows.
The closest work is Next Forcing, a concurrent and independent effort. Next Forcing conditions its future prediction on the full past representation, whereas FCP conditions on a more compact representation and opts for parallel prediction (detailed comparison in the paper's appendix).
First, what was measured. The central yardstick for the evaluation is physical plausibility. It is a demanding criterion for gauging whether scene changes were truly learned, and it governs whether a video "looks real." The main benchmark is Physics-IQ Verified, which directly compares the generated continuation against the real filmed video numerically (reference-based). Because it is not a VLM (a vision-language model, which watches a video and judges it in words) subjectively ruling "is this physically correct?", it is more sensitive to fine differences such as the timing and magnitude of changes. That is why the authors made this metric their primary one. The supplementary ones they used — WorldModelBench, PAI-Bench-G, PhyGround — rely on VLM judgment and may be less sensitive to such fine differences.
The numbers go like this. In a controlled comparison with training data and settings held identical, standard training's 27.6 rose to 30.9 with FCP (the IQ score on Physics-IQ Verified — a measure of how close the later part of a generated video is to the physical behavior of the real video, rated against a reference, higher is better). When models differ in training data and settings, you can't chalk up a score gap to the method alone, so this is a number to read as a relative difference under identical conditions rather than as an absolute value.
It shows up to the eye as well. In the scene of dominoes falling, the two models diverge just after the fall begins. The first frame or two look fine in both, and the difference emerges only in where things go next. With FCP the fall spreads in one direction, whereas with standard training the middle slumps down without direction over that unfolding stretch. In a scene of ice melting and the water level rising, FCP caught that subtle change and standard training missed it.
In the tables, "Teacher forcing" is the standard training method described above. The gain was largest when both the past-context representation and the (noised) generation-target representation were adjusted on both sides.
1.3B controlled comparison (Table 4, IQ). Standard training 27.6 → FCP 30.9. Broken down: refining only the clean past-context representation gives +1.2 (27.6→28.8), refining only the noised representation (the one to be denoised during generation) gives +2.3 (27.6→29.9), and combining the two gives +3.3 (→30.9). Parallel form 30.9 vs. chained form 30.1 (+0.8).
5B controlled comparison (Table 2, Wan2.2-TI2V-5B, IQ). I2V = "image→video" (given one opening frame, generate the rest); V2V = "video→video" (conditioned on a preceding video chunk).
| 5B model (Table 2, IQ) | Teacher forcing | FCP 5-offset (parallel) | 5-offset chained | Non-contiguous offsets (1,3,5) | |---|---|---|---|---| | I2V | 30.4 | 33.8 | 31.0 | 33.1 | | V2V | 40.6 | 44.4 | 39.9 | 43.5 |Supplementary benchmarks (Table 3, Wan2.2-TI2V-5B, matched settings, VLM judgment). WorldModelBench 7.22→7.64 (+0.42), PAI-Bench-G 81.13→82.38 (+1.25), PhyGround Physics 2.75→2.80, and so on — FCP generally came out ahead.
Cross-model table (Table 1, data and settings all over the place → for rough positioning). By the authors' summary, 5B+FCP outperformed larger bidirectional models (Wan2.2-14B, HunyuanVideo-1.5, Cosmos3-Nano) and comparable or larger autoregressive pretrained models (MAGI-1-4.5B, Helios-Base).
The training data mixed internally collected videos with WISA-80K, using each source's original text annotations. It centers on general real-world video with no physics-simulator data added. Videos longer than 5 seconds were selected and only the first 5 seconds or so were sampled at the model's default frame rate. The models were initialized from the official Wan checkpoints (Wan2.1-1.3B, Wan2.2-5B) and, under the I2V setting, generated chunks of 3 latent frames in sequence with the first frame fixed as clean context. The auxiliary predictors are 3 DiT blocks each.
FCP's auxiliary mechanism is used only during training and removed when generating actual video. And yet the effect remains. The secret lies in how the predictor is attached.
At first the authors shared parameters (the model's learnable values) with the main generator to do the prediction, but the two objectives pulled the same parameters in different directions and temporal consistency actually got worse. On the other hand, detaching the predictor entirely and training it alone leaves the main generator untouched. The authors took a middle path. They connected the auxiliary predictor to the generator's intermediate computations (hidden states), so that the error from the future prediction flows into the body of the generator. Because this error has already reshaped how the generator's body computes during training, the effect remains even when the predictor is removed at inference. As a result, the existing autoregressive inference process is left untouched and no extra cost is incurred.
The rest of the design choices follow the same principle: blocking new shortcuts. The auxiliary predictor drops the text prompt. Handing it the prompt as is would tip it off about "what happens in the future," creating a new shortcut where the predictor leans on the text rather than on the generator's representations. And when handling multiple future time points, the predictors are placed in parallel rather than chained. In a chained structure, information about the near future leaks into the far prediction, becoming yet another shortcut. In practice the parallel form beat the chained one, and the gap widened as the model grew larger. The authors read this as larger-capacity models being better at exploiting that leakage.
The standard training method is teacher forcing. The generator uses a Wan-family video diffusion model. The backbone is a stack of DiT (diffusion transformer, a diffusion-based transformer) blocks using chunk-causal attention, and the auxiliary predictor is a lightweight version of it with its own separate parameters. Features pulled from several generator layers are concatenated channel-wise, fused with an MLP (multilayer perceptron), and injected into each auxiliary DiT block via AdaLN (adaptive layer normalization) modulation. The auxiliary loss backpropagates through this connection into the generator's hidden states. Dropping the prompt cut parameters and compute too, and the parallel predictors are easy to run concurrently across GPUs or to switch on and off during training.
What the scores say extends only as far as this: the generated video has become more physically plausible. There are visualizations showing the internal representations take on clearer spatiotemporal structure, but that does not spill over into a claim that the model "understands" the scene. The authors too go only as far as the cautious possibility that this more structured representation could be useful for building autoregressive world models. On top of that, this gain came out of a lower total training compute budget than standard training — meaning the performance was not simply bought with compute.
Limits the authors acknowledge. They state outright that adding physics-simulator data could further improve physical plausibility when scaling up, but that they did not address it this time. They also grant that the auxiliary predictor captures a "plausible future" while its visual fidelity is limited, and they leave using it for sampling acceleration or generation-quality improvement as future work.
Limits as I see them. The axis of evaluation is effectively concentrated on physical plausibility. The authors themselves premise that scene change is multifaceted and that comprehensive evaluation is an open challenge, so whether the gain on the physics side carries straight over to other dimensions — the narrative quality of the unfolding, long-range consistency — is hard to assert from this paper's numbers alone. Also, the number of offsets (3, 5) and the auxiliary loss weight look like choices that drive performance, and it is worth keeping in mind that the figures above are results obtained under one specific configuration.
This isn't about porting a video model's training method straight into a work agent. The one thing to borrow is a way of designing evaluation: checking whether something looks good just by copying the previous state. What follows is not how ONTLE runs today but a hypothetical experiment we have not yet tried.
ONTLE's AI PM reads the work logs, messages, and commits that come in each day and writes a weekly briefing. Two abilities of different kinds are mixed in here: the ability to summarize recent reports well, and the ability to look ahead at coming risks. The catch is that a briefing that merely tweaks last week's report still looks fine if you only read the summary. It resembles the frame-copying FCP pointed to.
So we could narrow the evaluation target to a single thing — "schedule-slip risk" — and do this. Hide the intermediate reports and tell it: "I'll give you only the information up to three weeks ago. Judge how high this project's schedule-slip risk is right now, with the evidence and the uncertainty attached." Then set that answer side by side with how things actually turned out, and with a simple baseline that assumes "the last state from three weeks ago holds unchanged." Only if the task can't be cleared by copying the previous report does it become visible whether the prediction is really more useful than the simple baseline.
Let's also be clear about the difference between video and work. Dominoes flow by physical law, but a project can have its prediction thrown off by decisions made in between or by external events, so the past alone isn't enough. So this is less a report card of "right/wrong" than a diagnostic tool for looking at whether an agent is leaning on nothing but echoes of the past. As a first small experiment to try at ONTLE, it would be about right to predict just the one schedule-slip risk from the information available at the time in the weekly briefing and compare it against how things actually went and against the simple baseline.