Every frame of this was generated on one GPU in a spare room.
No cloud. No API key. Nothing left the building. A still-image model renders each shot, a video model animates it, and the whole thing is cut together on the same machine that made it — a desktop tower on a wooden floor, about a metre from where I'm typing.
I'm not showing you this because the output is flawless. It isn't, and further down I'll point at exactly where it breaks. I'm showing you because of what it cost to find out.
Why it matters ↓Captions burned in; the audio track is silent by design.
How it's actually made
Five stages, all open weights, none of them rented.
Nothing here is proprietary and nothing here is a secret. That's the point — anyone with the hardware can run this stack tonight. What takes time is knowing which knobs matter.
A diffusion model renders one vertical frame per shot at full 1080×1920. Six shots, six stills. This is the cheap stage and the one where composition is decided — get it wrong here and no amount of motion saves it.
An image-to-video model takes each still and animates it — 14 billion parameters, run in four denoising steps instead of thirty thanks to a distilled adapter. That single trick is the difference between a shot taking minutes and taking most of an hour.
Generation happens below final resolution because that's what fits in memory. A super-resolution pass brings it back up to 1080p and recovers the detail the smaller latent threw away.
A frame-interpolation model invents the frames between the generated ones, so motion reads as smooth rather than stuttering. Cheap, fast, and the single biggest quality-per-second win in the chain.
Typography, colour grading and assembly are plain old video tooling — no model involved. Held shots rather than fast cuts, because rapid cutting hides generation quality and a held shot proves it.
Where it breaks
The failures are more interesting than the successes.
Anyone can post the good take. Here is what actually went wrong making thirty seconds of video, because this is the part that tells you whether someone has really run the thing.
Faces dissolve
At the resolution the video model can actually fit in memory, a face that fills the frame comes back soft — smeared eyes, a smudged nose. The fix wasn't a better prompt. It was framing the shot from behind so there was no face to ruin.
Prompts escalate
I asked for "dust drifting" and "subtle haze" in the shot of the tower. Three seconds in, the model had the computer billowing white smoke and the room lighting up warm. It wasn't wrong, exactly. It just took the suggestion much further than I meant it.
Colour drifts
The video model regrades whatever it animates. One shot came back with a magenta light leak, another went yellow, and six shots that matched as stills no longer matched as clips. That gets corrected afterwards, by hand, like any other footage.
None of those are exotic. They are the ordinary texture of working with generative models, and you only learn them by running the thing until it breaks — repeatedly, on footage nobody is paying for.
Why it matters
The point isn't the hardware. It's permission to experiment.
When inference is metered, you only run the experiments you can already justify. Every speculative idea has to survive a cost conversation before it gets tried, so the weird ones quietly die and you never learn what they would have taught you.
When it isn't metered, you run the ones you can't justify. The video above took several complete re-renders — a whole opening sequence generated, judged, thrown away and rebuilt from scratch, twice. On a per-second bill I would have shipped the first acceptable version and never discovered that the second was better.
That's a different way of working, and it compounds. Not because local inference is cheaper on a spreadsheet — hardware isn't free and neither is electricity — but because it removes the little tax on curiosity that stops you trying things.
It's also how you build judgment about what these systems can and cannot be trusted with. You don't get that from a pricing page or a vendor demo. You get it from watching a model confidently set your computer on fire because you said the word "haze".
If this is the kind of judgment you want
Most teams are still deciding what to safely hand an AI agent.
My honest answer is usually "less than you'd like, and not yet." The Agent Readiness Audit is a two-week diagnostic that tells you which of your workflows an agent can run today, which will burn you, and what to fix first.
Same instinct as this page: find out where it breaks before it costs you.