Generative AI made making frames easy. It did not make making animation easy. The bottleneck moved upstream — into briefs, references, character continuity, episode variants, board approvals, animatic re-cuts, finishing, QA. So I built the part that actually breaks.
01The problem I was solving
A typical pre-production starts the same way every time. A pitch arrives as a Word doc, a deck, three voice notes, a Pinterest board, and a screenshot of a competitor's trailer. The producer types it into a brief. The director re-types it into a treatment. The art director re-types it into a style frame request. The writer re-types it into a beat sheet. By the time the script reaches the storyboard team, the original idea has been reformatted seven times by seven different humans, and continuity has already started to drift.
Now layer generative tools on top of that. Every model is happy to invent a hero on the fly. Hair colour shifts between shots, the dog grows a tail it didn't have last episode, the wardrobe is right for episode 3 and wrong for episode 7. Continuity used to be a department. With generative tools it has become an emergency.
I wanted a pipeline where the cast was sheeted before the script was locked, the script was format-aware before the boards were drawn, the boards were data before the animatic was cut, and the animatic was a daily tool — not a Friday-evening render job. So I built one.
02Architecture: eleven panels, one manifest
Every project in the studio is born inside Module 00 — the Content Input System. The operator drags in messy client material — emails, voice notes, decks, Pinterest boards. Picks a content format. Layers in seven taxonomy axes for tone, audience, and style.
The output is a single PROJECT.json manifest. That manifest is the source of truth for the next ten panels.
There is no re-typing anywhere downstream. Every module reads the manifest, knows what it is making, and writes its results back into the same structured layer. When a producer says "we are pivoting from a series to a 90-minute feature," it is one field change. The whole pipeline reroutes.
03Cast first. Write into the world.
Module 01 — Asset Design does the swap that most studios are afraid to make. It sheets the cast first, then the script gets written into the world.
Characters get full turnarounds, expression sheets, silhouette tests. Props get three-views. Environments get establishing plates. Every asset is text-described first and image-rendered second, so when continuity drifts mid-production we re-roll the image without re-rolling the design. The text is the contract. The image is the latest render of it.
Writers and directors compose against actual visuals, not blank squares. The world stays coherent. The downstream pipeline never has to guess what a character looks like.
"The cast becomes the contract. Every other module signs it before it makes a frame."
04One engine. Five story formats.
Module 02 — Story / Script Development is format-aware from line one. Series, movie, musical, documentary, ad — same engine, different beat grammar.
A 22-minute episodic act-break feels nothing like a 90-minute feature, and a 30-second commercial feels nothing like either. Most pipelines force a choice up front and rebuild everything if the format changes. This one does not. The same project can flip from a series treatment to a feature outline without a rewrite, because the manifest carries the format and the engine adjusts pacing, structure, and dialogue cadence accordingly.
Voice-locked dialogue respects character age, tone, and arc — anchored to the sheets that already exist in the visual bible.
05Variants as deltas, not duplicates
Episodic animation breaks because every episode generates new costumes, new accessories, new prop variants, and continuity drifts shot by shot.
Module 03 — Episodic Asset Development treats each variant as a delta on the locked base sheet. The face stays. The wardrobe changes. The hairstyle shifts for the rainy episode. The scarf comes out for winter. Identity is enforced by the data layer, not by hope.
Visual diff checks run against the base before any variant ships downstream. The cast does not change. The world does. And the pipeline knows the difference.
06Boards as data
Module 04 — Storyboard Generator turns the scene list into shot-decomposed panels in minutes. Every panel pulls the locked character sheets from Module 01 and the right episodic variant from Module 03.
- Scene to shot decomposition. Beats become numbered panels with action notes.
- Cast-aware panels. Characters render in their locked design and correct episode wardrobe.
- Camera language tagged. Lens, angle, and movement travel with each panel.
- Boards as data. Every panel is a JSON record with shot ID, length, cast list, and revision history.
07Animatics at daily speed
Module 05 — Animatics Workshop is the place that traditionally kills schedules. Someone opens Premiere, drags boards onto a timeline, lines them up to a temp track, exports, ships, gets notes, redoes it.
This module treats the animatic as a generated artefact. Boards from Module 04, voice clones speaking the Module 02 dialogue, and a music bed scoped to the project's tone — assembled, timed, and ready to re-cut in a single pass. Director re-pacing becomes a parameter change, not a manual re-edit.
The animatic stops being a render job. It becomes a daily tool.
08Model-agnostic generation
Module 06 — Animation Sandbox is where the actual moving frames get made.
Most AI animation pipelines marry you to one model. When the next breakthrough drops six weeks later, you rebuild. This sandbox treats the model layer as pluggable. Veo, Kling, Runway, Sora, open-source — same prompt, every backend, side-by-side comparable takes.
The sandbox auto-resolves the cast sheet, episodic variant, and storyboard panel into a model-agnostic prompt, fans it out to selected providers, and returns audited, labelled takes ready for the director's pick.
09Same pipeline. Different deliverable.
Once the cast is sheeted, the script is locked, and the boards are decomposed, the same data describes a comic. Module 06 — Comic Book Generator repackages the pipeline output as print-ready CMYK pages. Same characters. Same panels. Different deliverable.
The animation does not have to ship first. The comic does not have to wait. Same pipeline. Two products.
10Production-grade finishing
Module 07 — Reel Polish is the post-production queue that turns raw generative takes into shippable masters at production speed.
- Resolution upscale. Sub-1080p generations to 4K cleanly.
- Frame interpolation. 24fps to 60fps for high-motion deliverables.
- Denoise and grade. Match the project's locked colour and grain profile.
- Codec repack. H.264, H.265, ProRes, broadcast-spec output to the deliverable contract.
- One queue, one kill switch. Batch-driven, audited, interruptible.
Sandbox takes go in. Broadcast masters come out. Same day.
11The two outliers: MiroFish & UGC Pipeline
Two more panels round out the system, and they are the ones that surprise people.
MiroFish is an audience simulator. A million synthetic viewers, demographically tuned, read your treatment, your pitch deck, your trailer cut. Each carries a profile of age, market, taste, and comp-show familiarity. Twelve minutes later, you have sentiment scores, comprehension flags, pull-quote responses, and the rough shape of where the deck loses the room — before any real human reads it. Read more →
UGC Pipeline is the inverse — not the long form, but the volume play. One Google Sheet row in. One finished UGC, ad, or podcast video out. Avatar, voice, B-roll, captions, brand stings, and a vision-graded QA gate. All wired into a Sheet-driven pipeline that runs on a GPU instead of a junior editor. The factory behind owned and paid social creative. Read more →
Different problems. Same backbone. Same source of truth.
12Why this matters
I did not build this to be impressive. I built it because the alternative was burning a junior editor every six weeks and watching continuity drift kill three projects in a row.
The thesis is simple. Generative tools made the unit cost of a frame trivial. They did not make the cost of a project trivial. The work moved upstream — into briefs, references, continuity, format pivots, audience testing, finishing, QA. The pipeline that wins is the one that treats every one of those stages as structured data passing through a single manifest, not as a series of human hand-offs writing things into Word documents.
Eleven panels. One source of truth. Format-aware from line one. Cast-locked through final delivery. Model-agnostic at the generation layer. Audited at every step. Production-grade at the output.
Animation, accelerated. Pipeline, automated. At the speed of generation.