Most video refine demos run on a clip that's maybe three seconds long. That's fine for showing off sharpening, but it tells you nothing about what happens when you point the same pipeline at two minutes of footage. The honest answer: you don't run it as one job. You can't, not on one GPU, not with a model built to refine short windows.
Why you can't just feed it the whole clip
LTX 2.5 doesn't look at a full video and refine it end to end. It works on short windows, and in practice that means your long clip gets split into overlapping 73-frame chunks. Each chunk goes through the refiner on its own. There's no single-pass mode for a two-minute file, because the model was never built to hold that much context at once.
If you try to force it through as one run, you either run out of memory or the refiner starts losing coherence across the clip. Chunking isn't a workaround — it's the only way the model is meant to be used for anything longer than a few seconds.
One chunk, one run
In ComfyUI this maps to a simple rule: one chunk per run. If your source video breaks into, say, twelve overlapping 73-frame chunks, your batch count is twelve. Each batch item is a chunk, processed independently through the same refine pass.
This is why upscaling a full video takes real GPU time instead of the few seconds you'd expect from a short clip demo. Twelve chunks means twelve passes through the model, even if each individual pass is fast. The time scales with clip length in a way that a three-second preview never shows you.
The free LTX 2.5 upscale workflow is the right starting point if you want to see this on something short before committing a long render to it. Once you're working with anything past a few seconds, the long video version is built around the chunk-and-batch structure instead of fighting it.
Stitching without losing sync
Overlapping chunks exist so the refiner has continuity to work with at each boundary, but that overlap has to be resolved somewhere. That's the job of a writer node at the end of the pipeline — it takes the processed chunks, stitches them back into one continuous clip, and re-attaches the original audio in the same pass.
Doing audio re-attachment separately, after the video stitch, is where sync problems creep in. Chunk boundaries can introduce small timing drift if you're not careful, and video editors downstream won't fix that for you cleanly. Keeping the stitch and the audio re-attach in one pass is what keeps the final file in sync with what you started with.
This is also why the chunk size matters more than it looks like it should. 73 frames isn't an arbitrary number — it's long enough to give the refiner something to work with, short enough to keep each run inside reasonable memory and time limits. Changing it isn't something to do casually.
Refine strength: 0.40 is the number to start from
Separate from the chunking mechanics, there's the question of how hard to push the refine pass itself. A refine strength around 0.40 is the setting that keeps the character's likeness intact while still sharpening the footage. Push much higher and you start trading identity for sharpness — faces drift, details get reinvented rather than refined. Lower and you're barely touching the source.
0.40 isn't a hard ceiling, but it's a reasonable place to start before you go looking for more aggressive sharpening. If you're refining a trained character rather than a generic clip, that likeness preservation matters more than it does for background footage, so don't treat this as a one-size value to crank up by default.
A few practical settings worth keeping in mind when you set this up:
- Batch count = number of chunks, not an arbitrary round number
- Refine strength near 0.40 as a starting point, not a ceiling
- Let the writer node handle both the stitch and the audio pass — don't split them
The takeaway
Long video upscaling isn't a bigger version of the short-clip demo — it's a different job made of many small identical jobs, batched and then reassembled. Once you treat it that way, the GPU time and the batch count stop being mysterious, and the long video upscale workflow just becomes the chunking math you'd have done by hand anyway.
