One World, Every Episode

In short: Part 1 ended with an uncomfortable question — if almost anyone can build an AI commercial in an afternoon, what's left for someone like me? Here's the answer. It isn't in the first clip, it's in the second: episode two with the same characters, the same apartment, the same light — and then the whole season, consistent across hundreds of shots. Generating a single image has become a commodity. Holding an entire world consistent across episodes has not. That's exactly what I'm building a system for — and I'll be honest about how young it still is. The one-line version of this piece: Tools generate. A system produces.

---

The value is the second clip

Let's pick up where Part 2 left off. A single spot — even a well-directed one like the KLECKO ad — isn't the real value. The first one you can build today with some patience and the right tools. The value is the second: the same two sisters, the same apartment with the wall that didn't exist three times before, the same morning light, the same product — one episode on. And then episode three, four, a whole season.

That's where a neat gag turns into real craft. Because from the second clip on, a question shows up that a single pretty image never has to answer: is this still the same world? Tools generate an image. Producing a series means generating hundreds of images so that together they add up to one world. That's not a generation problem. It's a system problem.

Why an image model doesn't know a world

In Part 2 I described how my image model invented a new, conveniently placed wall three times in a row for one scene. For a single image, that doesn't matter. Across a series it's fatal: the moment the wall sits somewhere else in episode two, the illusion breaks.

It got more uncomfortable at quality control. I put a strong language model to work as a review layer on the storyboards — and even that missed gross continuity breaks: characters painting walls that didn't exist in the room; in the planned edit, walls were painted in one shot and bare in the next. Checking image by image doesn't catch this. Each individual image is plausible on its own — the break only appears in how the images relate to each other. The AI thinks of a lot, but not of everything. Consistency across a whole world isn't something an image model hands you on the side. You have to force it.

The load-bearing core: the consistent start frame

How do you force consistency? The lever sits earlier than most people think — not in the video, but in the start frame.

Every image-to-video run needs a start frame first: the one image the motion grows from. And that's where consistency is decided. Multi-image reference models like Nano Banana 2 or GPT Image 2 can produce start frames that stick to fixed references — to character sheets (the figure in several views), prop sheets (the product, the props), and backgrounds as a panorama floor plan. Certain regions of the prompt aren't reinvented every time; they're locked and repeated.

That's the underlying logic that makes video consistency possible at all — the load-bearing core. Not a magic consistency switch, but a reference discipline you hold to: define the world first, then derive every start frame from that world.

The system is an organization layer

For a 30-second spot you can still hold that reference discipline by hand — nine keyframes, one floor plan, two characters. For a series you can't. Hundreds of shots, dozens of characters, locations, props, and each figure not in one outfit but in many, across scenes and episodes. That's the point where doing it by hand tips into chaos.

So I build the layer that organizes exactly this. At its core, my tool is an organization helper: it names things automatically and cleanly. It assigns references to the right scene in the right context — it knows which character appears in a scene and which doesn't, and pulls in the correct character sheet, the correct location, the correct background by itself. It accompanies the creation of locations, backgrounds, characters. And it manages multiple outfits per character automatically — because in a real production a character doesn't have "plus one outfit," but many.

Anyone who has made film the classic way knows how complex this is: wardrobe, casting, location scouting, set design, production design. The system unites all those departments, sensibly sorted, in one surface across different tabs. It doesn't replace the craft — it gives it a stage where you keep the overview across hundreds of assets.

Just the logical sequence

The striking part: none of this is new. It's exactly the sequence film has always been made in. A rough concept and a treatment, then the screenplay, an extended film concept, a shot list of some kind, a storyboard — and then you went into production with that list, ended up with clips, and cut them. That's how it was done thirty years ago, and that's how it's done today.

What's new is only what fills the individual stages. I've connected the advantages of a language model and the creative work with that classic production system. AI video production changed everything — but the order in which a story becomes images stayed the same. And mapping exactly that order cleanly and end to end is something no tool on the market currently does in this form. That's my experience, not a lab benchmark — but I've looked for a long time.

One part of it alone already justified the tool: the storyboard work. Half-automated, consistently derived from the screenplay, sortable — and as a document you can hand a client for approval and conceptual alignment. Directing and story work in film are deeply visual. Seeing a proper storyboard you can sort and decide on isn't a nice-to-have — it's half the job.

The discipline that carries it

For organization to turn into production, it takes discipline in three places — and I know all three from the real set:

A locked directing signature instead of style drift. A directing and visual signature, defined once, is carried consistently through every shot, instead of the visual language slowly drifting apart over thirty setups. Visual consistency isn't luck; it's a held specification.

Approval gates like on a real set. Treatment, film concept, storyboard are stages the client signs off before things move on. That makes an AI production plannable and auditable — not "the AI just produced through," but traceable steps with a lock on every door.

End to end, from briefing to render-ready prompt. The shot list yields finished image, video, and audio prompts that go straight into the render bench — one seam less between creation and production. And because one workflow stays format-adaptive, the same project produces the spot, the cutdown, the longer version.

What even the best tool doesn't solve

I looked closely at the tool side — among others, higgsfield's surface, which since late April can also be driven by AI agents over an open standard. The breadth is impressive: image, video and audio generation, upscaling, reframing, motion control, tools for character references. A lot of it is excellent, and I'm happy to use tools like that.

But every one of those tools works at the shot level. It makes one image better, one clip longer, one movement cleaner. None of them carries a canon — a world bible, characters with fixed identity, enforced continuity — across an entire series. That's not a criticism; quite the opposite: a tool like that isn't a competitor, it's a different layer. It can even be a tool inside my pipeline, especially for straightforward single shots.

And that's the whole point of this series. The generation layer is becoming a commodity — it already is. Even the best toolbox in the world doesn't solve the series problem, because it sits at the wrong layer. Tools generate. A system produces.

The honest weakness

Now the part most people would leave out. I won't.

This series suite is young. So far only a few spots have really run all the way through the pipeline. Video generation currently costs a lot of tokens, and a good production costs a lot of time — both throttle the number of runs. The most honest tests ran inside real client projects, and those are exactly the ones I can't show: they're under NDA.

And so there's no false impression: the KLECKO spot from Parts 1 and 2 is itself not proof of this suite. I built that one directly over the MCP and held the consistency together by hand — sheets, a locked floor plan, "don't invent walls." KLECKO proved the principle. The suite is the machine that automates that principle so it doesn't end at a 30-second spot but scales to a season. Going forward I'll deliberately run small commercials — a next-generation "KLECKO 2000" — through my own pipeline instead of by hand. That's a vision with a foundation, not a vision without ground. But it's a work in progress, and that's what I'll call it.

Why I'm building this at all

My motivation is more sober than it sounds. It's about self-organization, saving time, and keeping the overview. I want to produce faster and more safely, keep my internal management — down to clean file names — readable, and stay competitive in a crowded market. On the side: cutting token costs and building a proper graphical interface so all that complexity stays operable.

And yes, I build this as a vibecoder: the concept, the architecture and the system thinking come from me, the code from the AI. My edge isn't in the keyboard — it's in what I bring from sixteen years of film and CGI: knowing the order in which a world is built, and the exact spot where it falls apart when no one is watching.

The takeaway: the value moves

Generation has become the commodity. The value moves to what stays hard: holding an entire world consistent across episodes. That's not a new trick — it's old production craft, rewired with a language model and AI video. Whoever builds the first clip operated a tool. Whoever builds the twentieth clip of the same world without it breaking has a system.

Honestly: it doesn't feel safe. The market is finite and flooded, the models keep getting better. But that's exactly why the bottleneck shifts — from making to holding together. And holding together is directing over time. That part is still needed.

Outlook

That closes "From a Blob to a Series." The arc was simple: a clip anyone can build today (Part 1) — the consistency wall full automation runs into (Part 2) — and the system that holds that wall across a whole season (Part 3). What remains isn't a tool tip but a stance: the tools become interchangeable. The system that binds them into a consistent world is the real value — and that gets built, not generated.

---

Jens Fehrmann delivers AI-assisted video and series production in live-action and 2D style — real productions with AI as a pipeline component, for agencies, production companies, brands and creators. New production methods, in use first and delivered reliably. Built on a foundation of 16 years in film and CGI, from Dresden.

---

Sources

This workshop report rests in substance on my own production data and development work — the KLECKO production of 25 June 2026, the reference and asset states, and the ongoing build of my series-production pipeline. These internal records aren't publicly linkable. The statement that the suite has had only a few runs so far and that client tests are under NDA is an honest self-disclosure, not external evidence.

The few external terms are standard tools or publicly known: Nano Banana 2 and GPT Image 2 as multi-image reference models, MCP (Model Context Protocol) as an open standard an AI agent uses to call tools, and higgsfield as an AI image/video platform with an official MCP (since 30 April 2026). The comparison draws on publicly available knowledge about these tools, not on internals.

AI disclosure: The header image of this article is AI-generated (abstract, illustrative). The making-of images are screenshots from work in progress or AI-generated production stills, and illustrate the process.

---

Want to take it further?

Message me directly — you reach me, not a team.