Consistent Character AI: Keeping One Character Across Scenes

Type the same character description into Midjourney, DALL-E, or Stable Diffusion twice, and you get two different people who happen to share a hair color. Ask a third time and you get a third person. This is the most common complaint in AI image generation, and it has a name: consistent character AI — the problem of getting one specific character to look like themselves across dozens or hundreds of generated images, not just one. Searches for the exact phrase have roughly tripled over the past year, which tracks with what anyone actually trying to build something longer than a single illustration runs into almost immediately.

The honest answer isn’t a magic prompt that finally produces the same character AI images every time. It’s understanding why the drift happens, which of the current tools actually narrow it (and by how much), and — for anything with real scene count, like a 20-minute video — treating consistency as a production pipeline instead of a one-off trick.

Why AI models lose your character between generations

Diffusion models — the engine behind Midjourney, Stable Diffusion, Leonardo, and most of the field — don’t edit a character. They sample one. Every generation starts from a fresh field of random noise and denoises it, step by step, toward whatever the text prompt describes. There is no character sitting in memory between calls. There is a probability distribution shaped by your words, and each click is one draw from it. That mechanism is the actual root cause of the AI character consistency problem — not weak prompting.

That’s the whole problem in one sentence: a text prompt can narrow the distribution (“red-haired woman, leather jacket, green eyes” rules out a lot of faces) but it can never specify a single identity precisely enough to rule out everything else. Add more adjectives and the range gets tighter. It never gets to one.

This is also why pinning the random seed feels like it should work and mostly doesn’t — more on that below. And it’s why every serious consistency technique on the market works the same way at a high level: instead of trying to describe the character more precisely in words, they feed the model a picture and tell it to condition on that instead. How well that works, and how far it scales, is where the tools actually diverge.

Midjourney's --cref and --oref: character reference, honestly assessed

Midjourney was the first mainstream tool to ship a dedicated feature for consistent characters — Midjourney calls it Character Reference (--cref), and it’s still the reference point most people mean when they say “consistent characters Midjourney.” It let you attach an image URL and have the model match that character’s face, hair, and general look in a new generation. As of Midjourney V7, --cref is legacy — it still works on V6 and Niji 6, but the current mechanism is Omni Reference (--oref), a broader tool that anchors characters, objects, and vehicles alike. A companion parameter, --ow, controls how hard the model leans on the reference, on a 1–1,000 scale with a default of 100 — higher values follow the reference more strongly, lower values leave more room for the prompt to move things around.

Midjourney doesn’t oversell this. Guidance compiled from Midjourney’s own V7 documentation is explicit that Omni Reference is not a guarantee: character details can still shift across lighting, pose, camera angle, clothing, and art style, and multi-character scenes are particularly unreliable because the model has to correctly assign which reference belongs to which person in frame. The practical workaround creators have converged on is to build one clean, neutral hero reference image first, keep --ow consistent across a batch, and review results side-by-side rather than trusting any single generation.

GPT-image and DALL-E: reference-and-edit, not reference-and-lock

OpenAI’s image tools take a related but distinct approach. GPT-image (the API-accessible version of the model behind ChatGPT’s image generation) lets you upload a character image and instruct the model directly — “using this exact character design, put them in a cafe” — and its in-place editor can change just a selected region, like a shirt color, while leaving the rest of the image alone. For a single edit, that’s genuinely strong.

Where it breaks down is sequences. Users on OpenAI’s own developer forum have documented this repeatedly: one reported that after asking the model to make a small change — turning a character slightly, keeping “the same image and full body” — they got back a completely different character, and noted that earlier versions of the tool had handled the same kind of edit correctly.

That’s the pattern across the thread: single edits hold up reasonably well, but a chain of edits compounds the same drift problem described above — each pass is still a fresh sample, just one that starts closer to the last output instead of from nothing.

Leonardo's Character Reference, and the LoRA option

Leonardo AI’s Character Reference is the most explicitly tunable of the reference tools. Technically it’s a ControlNet preprocessor: you supply a reference image and a strength setting — Low (weight roughly 0–0.66, maximum creative flexibility), Mid (0.66–1.32, balanced), or High (1.32–2, prioritizes resemblance over variation). Leonardo’s own documentation is careful to say this isn’t a face-swap feature and doesn’t guarantee a perfect replica — and it’s only available on SDXL and Phoenix models, not FLUX or earlier Stable Diffusion versions.

The technique that goes furthest is LoRA training: a small adapter model trained on 15–30 varied images of your specific character, which then generates that character’s face and proportions as a learned pattern rather than a prompt guess. It costs a few dollars in rented GPU time and takes minutes to a few hours, depending on dataset size and settings. This is closer to what “consistent” actually means — the identity is baked into the model’s weights, not re-guessed from text on every call — but it has real setup cost: curating a clean dataset, running the training job, and validating the result before you can use it in production.

Read the full post on X. That framing is common in AI-art circles for a reason: a LoRA is genuinely the closest thing to a solved version of this problem available today, for creators willing to do the training step upfront. Reference tools like --oref and Leonardo’s Character Reference are faster to reach for and fine for a handful of images. They’re a weaker foundation once the scene count climbs into the dozens.

Glibatree’s workflow in the video above is a useful real-world data point on where these tools land in practice. Building assets for a children’s book character from one client-supplied Midjourney reference, the creator didn’t rely on --cref/--oref alone — they used Midjourney’s image-to-video mode as a pose-locking trick, dragging the reference in as a starting frame and pulling individual frames back out as stills, then patched the outliers using stitched multi-image canvases in the Midjourney editor so the model had several correct examples of the face in view at once while fixing a bad one. Out of that process: 151 saved images, 23 that still needed manual correction.

The seed-pinning myth

One piece of advice keeps circulating: fix the seed, and you’ll get the same character every time. It’s intuitive — a seed determines the starting noise, so same seed plus same prompt should mean same output. In practice, same seed and same prompt produce related faces, not identical ones, and the moment you change anything else in the prompt (a new pose, a new outfit), the resemblance can fall apart entirely.

Diffusion researchers have a name for why: the mapping from a starting noise field to a final image is “many-to-one” in a way that makes most directions in that noise space nearly invisible to the output, while a small number of directions swing the result hard. One recent paper on the phenomenon describes it as a “seed lottery” — two seeds that look numerically similar can land on opposite sides of that boundary and produce sharply different faces. Pin the seed if you want reproducibility for debugging. Don’t rely on it as your consistency strategy.

The technique scorecard

Put side by side, the honest differences are about setup effort versus how far each technique holds up as scene count grows — not which tool is “best” in the abstract.

The production reality: 300 scenes is a pipeline problem

Every technique above is described in terms of a handful of images. A 20-minute narrated YouTube video runs 250 to 350+ scenes. At that scale, none of the tools above work as a single step you invoke and trust — including LoRA, which just moves where the effort sits. Glibatree’s 15% manual-fix rate came from a deliberate, multi-tool workflow built specifically to catch drift before it shipped. Run the same reference-and-generate loop without that discipline and the failure rate on a real project climbs, not falls, because nobody is checking image 40 against image 4.

What actually holds a character together at that scale is a pipeline, not a prompt:

• A locked reference, decided once. A hero image or trained LoRA that every later scene is generated against — not a new description improvised scene by scene.
• Per-scene regeneration against that lock, not one giant batch. Each shot is generated with the reference attached, so drift can’t compound silently across dozens of generations in a row.
• Systematic review, not spot-checks. Someone or something has to actually compare scene 40 to the reference, the way Glibatree’s “needs edits” pile did for the 23 out of 151 — at video scale that review step has to be built in, not improvised at the end.
• A fix-and-replace loop for the outliers, so a bad generation gets corrected and swapped back in rather than shipped because nobody wants to regenerate the whole batch.

This is exactly the gap Longform Studio is built to close for long-form video specifically: character references are locked once per project, every scene is generated against that lock instead of re-described from scratch, and regeneration happens per scene when something drifts — instead of a single blind batch of 300 images with no review step in between. It’s the difference between turning one prompt into a finished faceless video and turning one prompt into 300 images you now have to individually audit.

The same pipeline logic applies whether the format is narrative or nonfiction. Building an AI documentary generator that stitches together hundreds of shots without a matching identity-lock system runs into the same drift at the same scale — it just shows up as a narrator’s recurring illustrated avatar quietly changing hairstyles halfway through instead of a storybook character doing it. If you’re weighing tools generally rather than the consistency question specifically, our roundup of faceless AI video generators covers cost and capability side by side, and building a documentary without a film crew covers the format end of the same problem.

For a project the size of a long-form AI video generator is built to handle — 10 to 30 minutes of narrated footage, the question isn’t which reference feature to pick. It’s whether the tool treats character consistency as a pipeline stage with a review step, or as something you’re expected to babysit manually across every one of those 300 scenes yourself.