If you have made anything with AI video, you know the move. You write a scene, attach a few reference photos, and the first frame comes back looking great. You ask for the next shot, same character, same room, same props, and the world quietly rearranges itself: the dog's face shifts, the battered wagon becomes a different vehicle, a coat changes color between two shots that are meant to be the same afternoon. The footage is gorgeous and unusable, because nothing holds still.
The hard part of AI video is not the video. It is the stills. Reference images help. They do not lock anything down.
I run a small AI-animated show, The Doodle Cast, and that drift was the wall I kept hitting: the same dog has to read as the same dog across every shot of an episode, and it didn't. The reflex is to reach for a bigger, pricier model. But before paying for the upgrade, I wanted to know whether the model was even the problem. So I ran a controlled bake-off on one real episode: eight scenes, the same scenes through every lane, judged scene by scene by a structured AI-vision protocol with an adversarial pass that tried to refute each finding, including several of mine. The question underneath it: when the stills drift, is that a model problem you fix by buying a better model, or a discipline problem you fix for free? I ran the whole grid, a cheap model and a premium one, each with and without two no-cost prompt fixes, to find out.
The lanes
Four lanes rendered the same eight scenes. The split was along two axes: which model did the rendering, and what discipline was applied to the prompt and the references.
| Lane | Engine | Mechanism | Cost (8 scenes) | Latency/scene |
|---|---|---|---|---|
| A2 | Nano Banana 2 | Hygiene fixes only: clean prompts, prop canon as text, cleaned refs | $0.54 | 11.5s |
| B2 | Nano Banana Pro | Same, plus a 12-cell reference board | $1.07 + $0.24 | 21.5s |
| S | Nano Banana Pro | One 4K storyboard sheet, then per-scene refinement | $1.07 + $0.24 | 18.4s + sheet |
| C | gpt-image-2 | The previous round's winner, the bar to beat | ~$1.70 equiv | ~3 min |
The engines, named plainly: Nano Banana 2 is Google's gemini-3.1-flash-image-preview; Nano Banana Pro is gemini-3-pro-image-preview ("Nano Banana" is the nickname for Google's image line); gpt-image-2 is OpenAI's image model. Costs are API rates as of June 2026.
One thing worth being precise about, since it comes up below: gpt-image-2's higher price is not just a fancier-model surcharge. It conditions on every reference image at locked high input fidelity - the API will not let you turn it down - and OpenAI bills those high-fidelity reference reads as denser, costlier input-image tokens. That always-on high-fidelity read is exactly what makes it hold structure and fine detail so faithfully across shots. Google's Nano Banana API exposes no equivalent fidelity control and tokenizes reference images at its standard, much cheaper rate. So the premium buys a specific, non-optional capability - faithful high-fidelity reference conditioning - not a categorically better model. (That is an API and billing distinction; it does not mean Nano Banana reads references at lower fidelity.)
The cheapest lane came out on top. Plain Nano Banana 2, about $0.067 an image, with two fixes that cost nothing, landed in a dead heat with the previous round's gpt-image-2 on the solo scorecard, 7.8 each, and then beat it head to head on the same frame: first on all four scored dimensions, at about a third of gpt-image-2's cost and a fifteenth of its latency. "Prop consistency" here means holding a prop's canonical design across shots, not raw shot-to-shot continuity; layout continuity was not a scored column, and by eye it was gpt-image-2's strongest suit. Hold onto the word as-run: this lane ran gpt-image-2 on the prompts I had actually been using, not with the two fixes. Closing that gap, the premium model with the same discipline, is the rest of the article.
- The dimensions (1 to 10 each): prop consistency (is each recurring object the same object across its scenes), character likeness (does each character match its canon refs and stay the same individual), scene fidelity (does the frame contain what the script calls for), artifacts (photorealism, no hallucinated text or watermarks).
- Three passes: a solo pass scoring each lane in isolation with per-scene evidence; a head-to-head pass ranking the lanes against each other on the same scene; an adversarial pass that re-read the raw frames and tried to refute each finding. It earned its keep by killing some of my own claims, including my theory that none of the lanes ever got the prop-canon text, which it refuted by pointing at a lane that had rendered the brass yoke.
- Who judged: the solo scoring was a Gemini vision judge; the head-to-head and adversarial passes were a Claude vision model reading the raw frames, a different family from either contestant, which is the main guard on judge bias.
- The limits I can't wave away: the solo Gemini judge shares a family with the Gemini lanes, so take the solo column with that grain of salt; one judge per pass, not a human panel; one render per lane per scene, no fixed seed. I treat sub-point gaps as ties, not signal.
- Verify it yourself: the full per-scene scorecard, head-to-head rankings, adversarial verifications, and every frame, both rounds, are on the lab page: showspring.com/labs/scene-bakeoff.
Scope, quantified: eight scenes from one episode, two interiors (the Bonewagon cab) and six exteriors (the porch, the street, the jerky vault); two leads carrying heavy reference coverage (Rusty, Oreo) and two guests carrying light coverage (Esme, Molly); four recurring props (the Bonewagon, its brass WHEN dial, the U-yoke, the Jerky Vault). One case study, not a benchmark.
The two free fixes
State the canon in text. When a prop's canonical detail was written into the scene prompt in plain words, the model rendered it correctly across every shot. When it was left to the reference photo alone, it drifted. Lane A's prop-consistency score, judged in isolation across the eight scenes, was 4 before the fixes; with the canon stated in text it was 8. The brass yoke is the cleanest single case, but the same fix held the Bonewagon, the WHEN dial, and the Jerky Vault on model too. Showing the thing is weaker than stating it.
Clean the prompt. The watermark artifacts I had been blaming on the model were coming from my own prompts. The show name was baked into an image-style setting and had ridden along into 98 saved prompts, so the model kept trying to render that text into scenes. One data migration fixed it. Of 146 reference images, only four actually carried a mark.
The other three lanes
The reference board came second on every dimension and costs roughly 2.5 times the cheap lane. Worth keeping for episodes with large casts, where a lineup cell helps with scale. Skip it otherwise; the prop-canon text does most of the work on its own.
The storyboard sheet came last. The sheet itself looked internally consistent, but any flaw baked into a panel, a stray painterly style, gibberish text, one wrong dog, propagated into every refined frame. As an unattended step it amplifies errors instead of containing them. It only makes sense with a human approval gate: eyeball the $0.24 sheet, re-roll until it is right, then fan out.
| Lane | Props | Likeness | Fidelity | Artifacts | Avg |
|---|---|---|---|---|---|
| A2 (NB2 + fixes) | 8 | 8 | 8 | 7 | 7.8 |
| C (gpt-image-2, as-run)* | 8 | 7 | 8 | 8 | 7.8 |
| B2 (NB Pro + board) | 6 | 8 | 7 | 7 | 7.0 |
| S (storyboard) | 5 | 6 | 5 | 6 | 5.5 |
* gpt-image-2's row is its prior-round solo score, judged in isolation; the clean cross-lane call is the head-to-head, not this table. (The cheap pipeline before the fixes, lane A, round 1, scored 5.5; the 7.8 is the measure of two free changes.)
Why the as-run expensive model lost the dogs
gpt-image-2 held the steadiest composition from frame to frame and produced the worst character likeness, and those two facts have one cause. It does not paste your reference pixels into a new layout; it re-synthesizes the whole frame from the conditioning signal. The coarse, structural parts reconstruct faithfully: where the dashboard sits, where the driver's hands go, the rope, the map, the geometry of the cabin. The fine, identity-bearing parts get regenerated through the model's learned prior. Where the prompt left a gap, the prior filled it: the brief never described Esme and actively mislabeled the leads (it called Rusty a "golden doodle" and Oreo "black-and-white," both wrong), so the guest came back as a fawn, flat-faced pug and the cabin got a generic round wheel. It is tempting to read this as a law: identity drift is structural to a regenerate-from-scratch path, reference engineering can't fix it. The next section shows why that is too strong.
The missing cell: I gave the expensive model the same fixes
So far the comparison pitted a disciplined cheap model against an un-disciplined expensive one. That is a prompt difference as much as a model difference, and it is the easy way to flatter the cheap lane. The clean test is the fourth cell of the two-by-two: the expensive model with the same discipline.
So I ran it through the gpt-image-2 API, on the same eight scenes, with the same two fixes (prop canon stated in text, brand text stripped, the leads described correctly) and the same reference coverage the cheap lane got.
For the record, this is the strongest identity path OpenAI offers for stills. Its image models have no character-lock parameter and no character fine-tuning - OpenAI documents cross-shot consistency as a limitation, not a feature - so high-fidelity reference photos plus restated canon text are the entire toolkit. Pushing it past what the cheap lane got (more curated reference photos per character, OpenAI's own "preserve the exact likeness, do not redesign" phrasing, higher output quality) sharpened the likeness further still, turning the leads from plush toward photoreal - at even more cost and latency. I did not leave gpt-image-2's best on the table.
The catastrophic failure disappeared. With the yoke canon written into the prompt, gpt-image-2 rendered the brass U-yoke in both interior scenes, no round wheel anywhere. Esme came back as herself: black-and-tan, tan eyebrows, white chest blaze, tapered muzzle. The leads held. The scripted beats landed: the sepia warp outside the windows, the rope leash pulsing green. The thing I had called structural and unfixable was, in large part, a sentence I hadn't written.
| Discipline → | No fixes | + fixes (head-to-head avg, same judge) |
|---|---|---|
| Cheap (Nano Banana 2) | round wheel, drift (solo 5.5) | 7.4 (A2) |
| Expensive (gpt-image-2) | fails canon: round wheel, fawn-pug Esme | 8.6 (C2) |
The no-fixes column is qualitative; the +fixes column is the head-to-head average from one judge, so those two cells (7.4 vs 8.6) compare directly to each other, and not to the round-1/2 solo numbers elsewhere.
Judged head-to-head against the cheap lane on the same protocol, gpt-image-2-with-fixes tied on prop consistency, both lanes now pass the yoke test, and won character likeness, scene fidelity, and artifacts, each by one to two points. The clearest way to read that is not a row of decimals but who held up better on each dimension, judged on the same scene side by side:
| Dimension | Head-to-head winner | Why |
|---|---|---|
| Prop consistency | Tie | both render the brass yoke and the recurring props |
| Character likeness | gpt-image-2 | kept Esme's white blaze and Molly's red coat; the cheap lane dropped both |
| Scene fidelity | gpt-image-2 | cleaner staging of the same scripted beats |
| Artifacts / finish | gpt-image-2 | the cheap lane hallucinated garbled dashboard text on one frame |
The margin is clear but not huge: averaged on the judge's 1-to-10 scale it came to about 7.4 for the cheap lane and 8.6 for gpt-image-2, one render per scene with no fixed seed, so treat it as directional rather than settled (the calls are eye-checkable on the lab page). The shape is the point. Once both lanes have the discipline, gpt-image-2 is the better-looking lane on three of four dimensions and a tie on props. The cheap lane still held its own where continuity mattered: it kept the hero Bonewagon parked in the street scene that gpt-image-2 dropped, and rendered a more identifiable vault in one tight shot. Close fight, won on finish.
The re-synthesis mechanism is real: gpt-image-2 does rebuild each frame from its prior, and its house style still leans groomed and plush in the fine coat texture. What does not hold is the stronger claim that this makes canon identity unreachable for it. Given the canon in words, it reaches identity fine, and a little more cleanly than the cheap lane. The wall was the un-fixed prompt, not the model.
The technique worth keeping (un-scored): chaining
Separate from the lanes, the cheapest signal that holds identity is the previous frame itself. Chaining doesn't stop the re-synthesis; it re-anchors it. Instead of conditioning on canon photos that sit far from the target, condition each shot on the previous frame, the nearest possible reference: same cabin, same dogs, with the description controlling only what changes. One call, about $0.13. I did not put chaining through the scored bake-off; it is a single qualitative test, not a panel result. The catch is visible even in that one test: each frame inherits the last one's small errors, so identity ratchets over a long sequence. It is the answer for short, same-location runs, not for a whole episode generated cold.
What shipped, and the real takeaway
Three changes went into the pipeline: prop canon text in every scene prompt, the brand text stripped out of all saved prompts and reference images, and an optional reference board for cast-heavy episodes. New episodes get the winning behavior by default. The regression to watch is the cheap one: keep show branding, channel names, and meta-text out of image prompts and style settings.
These behaviors live in Showspring, the tool I run the show through, which holds character consistency two ways. For the prompt-and-reference engines, each character carries a canonical visual description plus a library of reference photos that reach the model as labeled images grouped by name, and a scene-reference feature lets any earlier rendered frame act as a visual anchor for later shots, with a "match appearance" flag that tells the model to keep collars, clothing, and accessories identical. For the heavier path, a character can be linked to a trained Soul ID, a fine-tuned model baked from a handful of photos, which locks identity at the model level instead of re-deriving it from references on every call - the weights-level approach OpenAI's stills don't offer.
It would be easy to stop at "the cheap model beat the expensive one." The fuller finding is narrower and more useful. In this test, the two free fixes did more than the model choice did: they moved the cheap lane from 5.5 to 7.8 and lifted the expensive model out of canon-failure. I would not generalize past this one episode, but here the fixes mattered more than the upgrade. The upgrade is not worthless; once both models are disciplined, the premium one buys you a little more likeness fidelity and a cleaner finish. But it does not buy the consistency you went looking for, discipline already did that, for free, and it bills three times the cost and fifteen times the latency to do it. For a serial show on a budget, the cheap lane plus the discipline is most of the result at a fraction of the price; reach for the premium model when finish on small characters is the thing you are buying, not when consistency is.
On this episode, the free fixes mattered more than the expensive upgrade did. Run the eval before you buy the upgrade.
In short
I went looking for a better image model and found a better workflow instead. On one real episode, a cheap model with two free prompt fixes, stating the prop canon in plain text and keeping my show's branding out of the prompts, held its own against a model several times more expensive and far slower. One episode is not a benchmark, so treat the numbers as directional. But the order of operations held up: run the cheap eval and clear the obvious prompt problems first, and you may find you never needed the upgrade.
Watch the episode
These frames are from The Doodle Cast, an AI-animated show I run in my own time. Here is the full episode they come from, so the consistency work above has something to point at.
More episodes at thedoodlecast.com and on the YouTube channel.
1 Comment
Join the discussion