We are making a fifteen-episode animated series, about twenty minutes an episode, entirely on hardware we own. This post is about the least glamorous part of that and the part that turned out to matter most: who writes the episodes.

The problem: the script was the expensive part

Episode 1 was written by hand. Episode 2 was planned with a large hosted model, and the bill for that one episode’s shot plan was 12.7 million tokens against an estimate of three to five hundred thousand. Fifteen episodes at that rate is on the order of 190 million tokens, which is not a rounding error, it is the project. So the writing moved onto our own GPU.

What does the writing now

Qwen3.8-27B (AWQ INT4), served with vLLM on one RTX PRO 6000, 97 GB of VRAM, which does nothing else while the series is being written. It is given about a quarter of the card — roughly 24 GB — because that is what this model needs at a 16k context, and vLLM reserves its share up front rather than growing into it; the rest of the card stays free for the clip rendering it goes back to once the writing is done. Measured over 315 calls, it generates at 72 output tokens per second.

Two passes, because one does not hold

A 27B model will not keep a page of rules in its head across a whole episode, so it is never asked to. The work is split:

1. The spine. One call returns the whole episode as scenes — heading, place, time of day, length, and a few sentences of what happens. Short enough to stay coherent. Median 46 seconds.
2. The beats. One call per scene returns what is said and done, with every spoken line written twice: once in Emirati Arabic and once in English. Median 8 seconds a scene.

Every answer is checked in code before it is accepted — scene count, headings, that a speaking beat really carries both languages and that the Arabic field really contains Arabic script, and that no character is named who does not exist in the series. A rejected answer goes back with its own failure quoted at it. Retries on a machine you own are free, so the checks can afford to be strict.

The bit worth passing on: don’t ask a model to add up

A twenty-minute episode is about 1,200 seconds spread over twenty-odd scenes. We first made that a rule and rejected any spine that missed the window. The model returned totals of 995, 1435, 880, 1435 and 1045 seconds on five consecutive tries. It understood the instruction perfectly every time; it simply cannot reliably add twenty numbers to a target. One of those attempts was five seconds short and was thrown away.

The fix was to stop asking. What the model is genuinely good at — and what nothing else can do — is the proportion: which scene is the long one, which is a breath, where the story turns. That survives scaling exactly. So the model decides the shape, and eight lines of arithmetic scale the durations to land on twenty minutes. The band it is held to is now generous, the retries mostly disappeared, and every episode comes out at exactly the right length.

The general form of that lesson: work out which half of the job is judgement and which half is arithmetic, and never pay a model to do the arithmetic.

A second trap: the example teaches harder than the instructions

The beats pass carries a real scene from a finished episode as the format to copy. The first version wrapped that example in its scene object — a heading with the beats nested inside. The model copied the wrapper exactly, returning one item instead of a dozen beats, six times out of six, while the written rules said plainly what was wanted. The example has to be the thing you are asking for. Once it was, the pass worked first time on most scenes.

Where it stands

Writing one episode this way takes about seven minutes of GPU time. The rest of the season is being written now.

And the pictures

The written scenes become shots, the shots become still frames, and the frames become clips. Right now episode 1 has 144 of 144 shots drawn and 20 of 194 clips rendered; episode 2 has 206 of 206 shots drawn and 43 of 299 clips rendered.

The stills are drawn with FLUX.2 klein 9B; the clips are Wan 2.2 S2V 14B, voice-driven, on RTX 5090s with 32 GB each; the voices are a self-hosted Arabic and English TTS; and every frame is checked by a vision model, Qwen3-VL-8B, on an RTX A5000 with 24 GB. No frame of it leaves our own machines.

Written 19 September 2026. Every figure above is computed from the run logs and the artifacts on disk at the time this page was built.