The video model rewrote our code and kept it sharp: what rented GPUs add to an explainer

The frame on the left says yaml.safe_load("country: NO"). Two seconds into the clip a 14-billion-parameter video model has rewritten it as yaml.safe_load("cointoy: OO"), added invented lines above and below it, and kept the glyphs sharp enough to pass for real code. By the last frame the red NO it was meant to highlight has faded out of the list. For a channel whose episodes are about exact characters (Episode 5 is about the word NO turning into False), that one frame settled most of the question this test was built to answer.

What was compared

How It Works & Breaks, the CloudLab Works explainer series, is drawn by a deterministic Python renderer on CPU: PIL draws each scene as a still, ffmpeg encodes the episode. The question was whether renting a datacenter GPU on Modal and running an open video model would make the episodes visibly better, and what it takes to set that up.

Both models are Apache-2.0, ran from the official Wan 2.2 code at a pinned commit, used the same prompt and seed for a given input image, and started from frames the existing renderer drew. Two inputs were tested: a text-free map of Norway in the episode's palette, and the episode's PyYAML code panel.

The two pipelines do different jobs, so the times are not a race. The renderer holds still frames for the length of the narration and never synthesises a frame; the video models synthesise every frame. The fair reading is "a whole episode" against "one five-second shot".

What the GPU bought

Motion on text-free shots, with a trade-off between the two models.

• TI2V-5B moved a lot and followed the camera push-in. It also invented a burst of white rings centred over Sweden

instead of Oslo, scattered particles across the map and let Norway's coastline swell. By the last frame its structural similarity to the input had fallen to 0.75. Dramatic, and no longer a correct map.

• I2V-A14B kept the map almost exactly as drawn (similarity 0.97 at the last frame), with the rings around Oslo pulsing.

It ignored the push-in, so the result is closer to a living still than a camera move.

Nothing usable on text. TI2V-5B turned the code into rows of red glyph noise within a second and changed the red NO to HO. I2V-A14B did the more dangerous thing shown at the top: sharp, plausible, wrong code. On a channel that teaches by showing exact strings, a shot that looks correct and is not is worse than one that is visibly broken.

What it took to set up

From a Modal account that already existed to the first clip saved on disk took about 30 minutes for an agent working through it, including one lost clip. The friction, in the order it appeared:

1. The Modal CLI could not reach its servers through the lab's egress proxy. Its gRPC traffic does not pass an HTTP

proxy; the fix was running the CLI with the proxy variables unset. A corporate proxy would likely hit the same wall.

1. Wan 2.2 requires flash_attn with no fallback, so the image needs a prebuilt wheel that matches the exact torch,

CUDA, Python and C++ ABI. The package also imports its audio and animation pipelines even for image-to-video, which pulls in dependencies missing from its requirements file.

1. The A14B weights are 126 GB, two full-precision expert models. That sets the storage size and roughly 128 GiB of host

RAM for the container, a line item easy to miss when only the GPU is priced.

1. A result that contained a library object the laptop could not unpickle lost the first finished clip. The fix was

returning plain types and saving each clip to persistent storage before returning.

1. Launching four jobs within 30 seconds hit an app-creation rate limit. The refusal happened before any container

started, so it cost nothing.

1. The README's flag for smaller cards moves the text encoder to the CPU. On one container whose CPU lacked bf16

instructions, that step took 7.5 minutes instead of about 25 seconds while the GPU sat idle and still billed.

None of these was hard. Each cost minutes, and about a fifth of the GPU time went to attempts that were stopped or lost. The image build (148 s) and the weight download into a Modal Volume (about 9 minutes, CPU only) are one-time costs.

When calling on Modal makes sense

• The model does not fit locally. A14B needs an 80 GB GPU; nothing in the lab has one. Renting it by the second is the

only way to run it without buying hardware. (The 5B model does run on Apple silicon, about 22 times slower per step; the 14B does not fit.)

• The work is a burst, not a service. A handful of hero shots per episode is minutes of GPU time a month; per-second

billing and containers that stop when the job ends suit that pattern.

• The stack is CUDA-only. flash_attn is the deciding dependency here; Apple silicon cannot run this code path.
• Choose the GPU by cost per step, not cost per hour. On A14B the H100 ran each sampling step about twice as fast as

the A100 and came out cheaper per step, despite the higher hourly rate. The A100 run would also have overrun the job's 45-minute timeout.

And when it does not:

• Anything that must be exact. Code, configuration, numbers, captions and diagrams stay with the CPU renderer, which

draws them correctly every time in seconds.

• Anything the model would have to invent. Image-to-video improvises; it is a fit for atmosphere, not for evidence.
• Storage left running. The weights stay billable in the Volume after the GPUs stop; delete them or budget for them.

What the test points to

The CPU renderer stays the right tool for every exact element of an episode. If generated footage is used at all, this test only supports text-free hero shots, made with the model that preserves the source frame, and labelled as altered or synthetic content where the platform asks for it.

Limits of this test

One prompt and one seed per model and input, at the models' default settings. Quality notes are visual judgement from sampled frames, not playback review. Structural similarity is dominated by flat background and does not measure legibility. Wan's default negative prompt includes terms for "subtitles" and "static", which may push the models away from stable on-screen text; that was not tested.