Video Generation · Diffusion Models · Multimodal Models
SANA-Streaming vs LoomVideo vs CoVEBench: Video Editing Compared
SANA-Streaming edits 1280x704 at 24 FPS on one RTX 5090; LoomVideo unifies generation and editing in 5B (VBench 63.15, 5.41x faster edits); CoVEBench shows editors still fail compositional instructions.
One field, three different questions
“AI video editing” in 2026 hides at least three distinct engineering problems, and three mid-2026 papers each take one of them head on. SANA-Streaming asks: can video-to-video editing keep up with a live frame stream on a single consumer GPU? LoomVideo asks: can one small model generate and edit video without paying the token-concatenation tax? CoVEBench asks the uncomfortable one: when a prompt bundles several coupled edits, do models actually do all of them?
The three papers barely overlap in method, and they never share a benchmark. That is the point of this comparison. Speed, unification cost, and instruction reliability are three different currencies, and a model that wins one can lose the other two. If you are building or buying a video editing system in 2026, the honest question is not “which editor is best” but “which of the three bottlenecks is mine.”
Key numbers
The first table is a side-by-side overview. Treat it as a map, not a ranking: no row was measured under the same protocol for all three systems.
| Dimension | SANA-Streaming | LoomVideo | CoVEBench |
|---|---|---|---|
| Role | Real-time streaming V2V editing system | Unified 5B generate-and-edit model | Compositional editing benchmark |
| Headline claim | 24 end-to-end FPS at 1280x704 on one RTX 5090 | VBench 63.15 with 5B; editing 5.41x faster than OmniWeaving | 626 multi-point instructions over 416 videos, graded by 9,990 checklist items |
| Core mechanism | Hybrid DiT (linear attention plus a softmax-attention block), Cycle-Reverse Regularization, Blackwell kernels plus MPQ | Scale-and-Add conditioning: add the scaled source latent instead of concatenating tokens | MLLM-judged instruction compliance and fidelity, plus automated quality metrics |
| Same-harness evidence | Internal only (24 vs 58 FPS, pipeline vs DiT core) | Internal benchmark tables (VBench, editing time, RefVIE-Bench, FashionVideoBench) | Internal only (no per-model scores published in the abstract) |
| Known blind spot | No published temporal-consistency metric or named baselines | No clean ablation isolating Scale-and-Add from the MLLM encoder and Deepstack | Checklist grading says what failed, not which model is best overall |
The second table collects the genuinely same-harness rows, all from within single papers. These are the numbers you can trust, because both sides of each comparison ran the same protocol.
| Same-harness comparison | Numbers |
|---|---|
| LoomVideo VBench average (RL-tuned) | 63.15 vs UniVideo 13B 63.01, Wan 2.2 5B 62.50; imaging quality 70.92 leads both |
| LoomVideo editing time, 480x832x97 video | 166.30s vs OmniWeaving 899.32s (5.41x) and UniVideo 6140.18s (about 37x) |
| LoomVideo text-to-video time | 132.23s vs OmniWeaving 824.93s (6.24x) |
| LoomVideo generation-to-editing cost growth | 132.23s to 166.30s (26% rise) vs UniVideo 1792s to 6140.18s (3.4x jump) |
| LoomVideo RefVIE-Bench overall | 3.78 vs UniVideo 3.38 and Kiwi-Edit 2.96; subject fidelity 4.50, background 3.98 |
| LoomVideo FashionVideoBench | 4.59 vs VINO 4.38, UniVideo 4.26, OmniWeaving 3.56 |
| LoomVideo multi-image TIV2V | 4.24 average vs OmniWeaving 3.89 |
| SANA-Streaming throughput split | 24 FPS end-to-end vs 58 FPS for the DiT core alone |
| CoVEBench benchmark scale | 416 source videos, 626 instructions, 9,990 checklist items; per-model scores not in the abstract |
Two rows deserve a second read. The 26-percent versus 3.4x row is the cleanest evidence in either system paper that a mechanism works: when LoomVideo switches from generating to editing, its runtime barely moves, because Scale-and-Add never grows the token sequence, while a concatenation-based 13B model blows up 3.4x on the same transition. And the SANA-Streaming split row tells you the model is not the bottleneck: the DiT core alone runs at 58 FPS, so the surrounding pipeline eats more than half the frame budget.
SANA-Streaming: editing that keeps up with a live stream
The premise of SANA-Streaming is that real-time video-to-video editing has two demands that fight each other. Throughput must clear the incoming frame rate, and temporal consistency must keep frame N agreeing with frame N-1. Most prior editing methods optimized quality on offline clips, then either ran far below real time or drifted on long streams. The paper’s answer is co-design: a hybrid diffusion transformer that keeps the SANA family’s cheap linear attention in most blocks but pays for softmax attention in one block where local detail needs it, a Cycle-Reverse Regularization training trick that predicts source frames back from generated content so no paired long edited videos are needed, and Blackwell-specific fused kernels plus mixed-precision quantization tuned by profiling real throughput.
The published anchors are hard numbers: 1280x704 resolution, 24 end-to-end FPS, 58 FPS for the DiT core in isolation, all on a single RTX 5090. The paper also claims its system outperforms existing state of the art on both temporal coherence and throughput, but the available material does not name the beaten baselines or publish a single consistency metric value, so treat that claim as directional. What you can take to the bank is the throughput figure and the architectural argument: real-time high-resolution editing is now a consumer-GPU problem, not a datacenter problem, which matters for broadcasting and gaming where round-tripping to a server is a non-starter.
LoomVideo: one 5B model for generation and editing
LoomVideo attacks a different cost. Unified editors usually hand the model a source clip by concatenating its latent tokens onto the target sequence, and because self-attention is quadratic in sequence length, a second video roughly quadruples the attention compute. LoomVideo instead scales the clean source-video latent by a learned factor and adds it to the noised target latent, so the sequence never grows. Everything else in the paper supports that one move: a Qwen3-VL 8B MLLM reads prompts instead of a T5 text encoder, Deepstack injects features from multiple MLLM layers, and a Negative Temporal RoPE parks reference frames outside the generated clip’s timeline.
The result is a 5B model that edits a 480x832x97 video in 166.30 seconds against 899.32 seconds for the 8.3B OmniWeaving (the published 5.41x) and 6140.18 seconds for the 13B UniVideo. On VBench the RL-tuned variant scores 63.15, edging UniVideo’s 63.01 and Wan 2.2’s 62.50 with under half the parameters of the first. The misread to avoid: every baseline is another open unified system, there is no comparison against frontier closed video generators, and 63.15 is a strong open-model score at a capability tier, not a new quality ceiling. The honest claim is efficiency: fold text-to-video, instruction editing, reference-image editing, and multi-image-to-video into one small model and edit cheaply. Notably, the paper’s own text-to-video versus editing timing (132.23s versus 166.30s, a 26% rise, against UniVideo’s 3.4x jump) is stronger evidence for Scale-and-Add than the headline 5.41x, because that cross-model multiple partly reflects parameter counts.
CoVEBench: the instruction-following gap nobody’s leaderboard shows
The third paper changes the question from “how fast” and “how cheap” to “does it do what was asked.” CoVEBench starts from the observation that real user requests are compositional: one prompt often demands several coupled edits, changing subjects, actions, and camera views while strictly preserving everything else. Existing benchmarks, built around isolated single edits and coarse global metrics, cannot diagnose how models handle that. CoVEBench builds the missing test: 416 curated source videos, 626 multi-point editing instructions, and 9,990 fine-grained checklist items, graded by MLLM judges for instruction compliance and video fidelity alongside automated quality metrics.
The finding, as published, is qualitative but pointed: current models frequently omit edits, violate preservation constraints, or introduce artifacts when several operations land in one prompt. The abstract does not publish per-model scores, so this page will not invent a ranking. The contribution is diagnostic: a checklist of 9,990 items says which of the bundled edits survived and which did not, which is exactly the failure surface that a VBench average or an editing-time table hides. For builders, the uncomfortable implication is that the two system papers’ headline numbers were measured on tasks easier than what users actually type.
When to use which
Choose by bottleneck, because the three papers are answers to three different questions.
- Latency is the bottleneck (live streams, on-device, no server round trip): SANA-Streaming is the only one of the three designed for it, and its 24 FPS at 1280x704 on one RTX 5090 is the only published real-time anchor among them.
- Cost and product scope are the bottleneck (one model that both generates and edits): LoomVideo’s Scale-and-Add is a near-free conditioning swap if your editor currently concatenates a reference clip, and its flat generation-to-editing cost curve (26% versus 3.4x) is the portable lesson.
- Quality assurance is the bottleneck (you ship an editing feature and need to know what breaks): CoVEBench’s checklist grading tells you which bundled edits fail, not just whether the output looks plausible. Run it before trusting any average score.
A team building a serious product probably needs all three lenses: SANA-Streaming’s co-design discipline for the serving path, LoomVideo’s conditioning trick for the model, and CoVEBench’s evaluation logic before claiming the feature works.
Limits and open questions
The deepest gap is that the three papers never meet. SANA-Streaming’s real-time throughput was never run through CoVEBench’s compositional checklist, LoomVideo’s Scale-and-Add editing was never scored on instruction reliability at streaming resolutions, and no paper measures what happens to a 626-instruction prompt when the editor must also finish each frame in 42 milliseconds. Any table that ranks the three against each other is fabricated, and this page deliberately does not contain one.
Within each paper there are smaller but real holes. SANA-Streaming’s temporal-consistency superiority is claimed without a published metric or named baselines, its 24-versus-58 FPS split is not decomposed, and its numbers are tied to Blackwell hardware, so portability is unknown. Cycle-Reverse Regularization reconstructs source frames from generated content, which could bias edits toward under-changing the input. LoomVideo has no clean ablation isolating Scale-and-Add from the MLLM encoder and Deepstack, no wall-clock comparison at matched parameter count, no memory accounting for the extra 8B MLLM, training data skewed toward e-commerce and fashion (which inflates its FashionVideoBench 4.59), and named visual artifacts under highly dynamic scenes. CoVEBench’s checklist judges are MLLMs, so its compliance scores inherit judge bias; its coverage is bounded by the 416 source videos it curates; and without published per-model scores, readers cannot yet track the field’s progress on it.
FAQ
How fast is SANA-Streaming compared with its own DiT core?
24 end-to-end FPS versus 58 FPS for the DiT core alone, both at 1280x704 on a single RTX 5090. The gap means the surrounding pipeline, not the model, is the bottleneck.
What does LoomVideo’s 5.41x speedup mean, and against what?
It is the editing-time ratio against OmniWeaving (8.3B) on a 480x832x97 video: 166.30s versus 899.32s. Against the 13B UniVideo the gap is about 37x (166.30s versus 6140.18s). Because the comparison spans different parameter counts, the flatter same-model signal (text-to-video 132.23s to editing 166.30s, a 26% rise) is the more trustworthy evidence for Scale-and-Add.
What does CoVEBench measure that VBench does not?
VBench averages holistic generation quality. CoVEBench decomposes 626 compositional editing instructions into 9,990 checkable items across 416 source videos, so it can report that a model omitted edit three of five, violated a preservation constraint, or added an artifact, rather than just scoring the clip.
Which video editing model wins across all three papers?
None can be declared a winner: the three papers use different protocols, different hardware, and different metrics, and no shared benchmark exists. Each leads on its own axis (throughput, unification cost, instruction reliability) and is untested on the other two.
How should a builder combine the results of these methods?
Adopt LoomVideo’s Scale-and-Add conditioning for the model, SANA-Streaming’s co-design discipline (hybrid attention, cycle regularization, profiled quantization) for the serving path, and CoVEBench’s checklist evaluation before launch. Each is a partial answer; the missing experiment is all three on one system.