What holds a moving picture together

The problem, stated exactly

Take an image model and generate 120 frames with the same prompt and 120 different seeds. You get a slideshow of unrelated pictures. Use the same seed for all of them and you get 120 copies of the same picture, which is a still.

Video needs the middle case: frames that are related but progressing. Producing that requires the model to know, while generating frame 47, what frames 40 to 60 look like.

Three architectural approaches have been used, and each one's characteristic failure is worth recognising.

Temporal layers bolted onto an image model. The earliest working approach: take a trained image model, insert layers that attend across frames, and train only those. Cheap, and it inherits the image model's quality. Its signature failure is texture flicker — the overall shapes hold while surface detail boils and shimmers, because the spatial layers were never trained to keep texture stable.

Joint space-time attention. The whole clip is one tensor and attention runs over space and time together, in a single trained model. Much more coherent, much more expensive, and this is what current strong models do. Its signature failure is at the window boundary rather than within it.

Causal or autoregressive video. Each chunk is generated conditioned on the previous one, in order. This allows arbitrary length and streams in real time, at the cost of drift, which the extension lesson covers.

The window, and why it decides everything

Whichever architecture, the model has a finite attention window — the number of frames it can consider at once. Inside that window, consistency is enforced by the model's training. Outside it, nothing enforces anything.

This single fact predicts most of what people observe:

• A jacket keeps its buttons for four seconds and changes at five.
• A character walks out of frame and returns as someone else.
• A pan across a room shows a door that is no longer there when the camera comes back.
• Two clips generated from the same prompt do not match, and no setting makes them match.

Object permanence is the clearest case. Something occluded and then revealed must be reconstructed from information that has fallen outside the window. What comes back is a plausible thing of that kind, not the thing that went in.

What improves it, and what does not

Improves it: a stronger base model, generating within a single window rather than joining clips, simple scenes with few objects, and shots where nothing is occluded.

Does not improve it: prompting for consistency. consistent lighting, same character throughout addresses nothing mechanical. It is the same category of mistake as writing exactly five for a count.

Partly improves it: conditioning every chunk on a shared reference image, which anchors identity without enforcing continuity of everything else.

The flicker you can fix in the edit

Some temporal artefacts are cheaper to remove afterwards than to prevent.

High-frequency texture boil responds well to a light temporal denoise in a video editor — DaVinci Resolve's free edition has one, and so do free plugins for Kdenlive and Shotcut. It works because the flicker is uncorrelated between frames while the real image is correlated, so averaging across a few frames removes one and keeps the other.

Brightness flicker between frames is fixed by a deflicker filter, which normalises frame luminance. This is a solved problem borrowed from film restoration.

What cannot be fixed afterwards is content changing — a different jacket, a vanished object. That is a reshoot, which in this medium means a regeneration.

How to find a model's window

You are rarely told the number, and you can measure it. Generate the longest clip the model allows, of a subject with one distinctive, arbitrary detail — a patterned scarf, a coloured mug, a sticker on a laptop. Step through the output frame by frame in any free editor and note where the detail changes.

Do this three times and take the earliest failure rather than the average. That frame number, divided by the frame rate, is the honest length of a shot you can plan on that model. It is usually shorter than the maximum the interface offers, and knowing it converts a vague frustration into a production constraint you can design around.

The honest summary: consistency is bounded by the attention window, the window is set by the model and the memory available, and no amount of prompting extends it. Plan shots that fit inside it, exactly as a director plans shots that fit inside a magazine of film.