The law held on a second model. The number attached to it did not.

If you want a video model to produce more than a few seconds, you have to chain: generate a chunk, feed its last frame back in, generate the next. Everyone does it. It is the obvious architecture and it is how error gets in.

I measured what that costs on a small open model, and the answer was brutal enough that I built a whole pipeline around avoiding it. Then I ran the same measurement on a different model family to see whether I had learned something about video generation or something about one model.

The answer turned out to be both, in a way that cost me a number I had been repeating.

What the first model said

Three findings, on LTX-Video-2B.

Never chaining is clean. Condition every chunk on the same fixed reference image, never on generated output, and the failure rate is a few percent.

Chaining collapses. Feed the previous frame forward and the run falls apart — 78% to 98% of chunks destroyed, depending on how strongly you weight it.

And collapse is a one-way door. Once a chunk collapses, the next one collapses, and the one after that. Across every arm I measured, not a single recovery was ever observed. The smeared frame becomes the input to the next chunk, which produces a worse frame, forever.

That third property is the one that matters architecturally. It means failure is not a rate you can average over — it is a cliff you fall off once. And it is why the pipeline works at all: if you never chain, a bad chunk cannot poison its successors, so you can simply detect it and draw it again. Redraw-on-detect only exists because failure stays local.

The depth number I extracted was that you get about three chained steps before the odds turn, and by five, collapse is certain.

I quoted that figure a lot.

The obvious objection

All of it came from one model family. The honest reading was that I might have characterised LTX-Video-2B rather than image-conditioned video diffusion.

So I ran the same experiment on Wan 2.2 — a different architecture, different training, from a different lab — scored by the identical detector at identical thresholds, because a cross-model claim rests entirely on the two being judged by one instrument.

The shape transferred, exactly

Never-chained, on Wan: 40 clean chunks out of 40, on each of two seeds. Eighty chunks, not one failure. Cleaner than LTX's own never-chained arms.

Chained: it collapsed.

And the absorbing property came back precisely. Here is the per-chunk record of one chained run, where . is a good chunk and X a collapsed one:

......................XXXXXXXXXXXXXXXXXX

First collapse at chunk 22. Then eighteen consecutive failures and zero recoveries — the same one-way door, on a model that shares no weights with the first.

So the law is a property of the architecture class, not of one model. That is the result I wanted, and it is the boring half.

The number did not transfer at all

LTX is gone by chain depth five. Wan survived to depth 22 on one seed and 32 on the other.

Four to six times deeper. And it did that while being asked a harder question — Wan's chained arm conditions on the previous frame and nothing else, which is past the end of the axis LTX was ever tested on.

So "you get about three chained steps" was never a fact about video generation. It was a fact about one model, and I had been repeating it as though it were general.

The bit that sharpened the analysis

The two seeds disagreed a lot on collapse rate — 0.450 against 0.200 — which initially looked like ugly variance in need of more seeds.

It is not variance. It is arithmetic.

Because collapse is absorbing, once a run falls over it stays over, so the number of collapsed chunks is just however many chunks remained. Onset at 22 in a 40-chunk run leaves 18 collapsed: 0.450. Onset at 32 leaves 8: 0.200. Exactly.

The collapse rate says more about how long I ran the experiment than about the model. Run it for 60 chunks and the same model reports a worse number; run 25 and it reports zero. It is not a property of anything.

The parameter that survives is onset depth — how many chained steps until the door swings shut. That is what I should have been measuring, and it is what I will quote from here.

What it changes

The practical advice is unchanged and now rests on two architectures: redraw-on-detect works only at zero chaining, because it depends on failure staying local, and that is true on both models.

But the reason to avoid chaining got weaker in an interesting direction. On LTX the safe amount was zero, because three steps is not enough to buy anything. At 22 steps there is suddenly a middle: chain for a while, re-anchor before the door closes, repeat.

So I ran that, pre-registered, with the prediction I most expected to fail written down in advance — that the seams would actually improve. Chained chunks share a timeline, but they also drift, and the drift might dump back at the re-anchor exactly what continuity bought in between.

They improved. Chaining 6, 12 and 20 steps between re-anchors all collapsed zero times — as safe as never chaining — and the seam between chunks fell 59%.

The mechanism sits in one number. A chained join measures 1.4, and it does not degrade with depth: the twentieth chained frame joins as smoothly as the first. A re-anchor join measures 17 to 37, and it grows the longer you chain, because the scene has drifted further from the anchor before snapping back.

Which means the seam was never a property of chunked generation at all. It is what re-anchoring costs — and never-chaining pays that cost at every single chunk. Bounded chaining pays it once per cycle and gets the smooth join for everything in between.

I also got the extrapolation wrong, in a way worth recording. After three data points I fitted a line to that growing re-anchor cost, got r² = 1.0000, predicted where the fourth would land, and sealed it. The actual value came in well under: the growth per step falls from 1.82 to 1.03, because drift saturates — a scene can only wander so far before it is bounded. A perfect fit on three collinear points told me nothing about the fourth, and I had treated it as though it did.

Limits

Two seeds, 40 chunks per arm, one scene on each model. Onset depth 22 and 32 brackets a range, not a constant — and with an absorbing process, a single run gives you one number, not a distribution. An onset beyond chunk 40 would have been invisible to this design. The two models' chained arms are not matched on conditioning strength, so this answers "does chaining collapse at all on another architecture", not "does it collapse by the same amount".

Bounded chaining is one seed, 30 chunks per arm, one scene. Every k tested collapsed zero times and the seam was still improving at the largest k I ran, so the optimum is unlocated and "chain as deep as you like" is not what this shows — only that the safe range is far wider than one model suggested.

And one process note, recorded because the alternative is quietly not mentioning it: I did not seal a prediction for the chained arm. I checked the run's progress to timestamp a pre-registration and the partial result was on screen before I had written one. Registering a prediction after seeing 39% of the outcome is worthless, so there isn't one. The bounded-chaining experiment that followed was sealed properly, before any of its data existed.