How to Build a Consistent AI Character Across Images and Video (2026)

To build a consistent AI character across images and video in 2026, lock one canonical face reference, generate a character sheet from it, carry that same reference into a reference-to-video model, hold the reference across every shot in a sequence, and upscale the hero frames last. The identity stays stable because every generation reads from the same source reference rather than from the previous take. That single discipline — one reference, wired everywhere — is what separates a recognizable recurring character from a face that slowly becomes a different person by generation four.

A consistent AI character is one whose face, build, hair, and signature wardrobe stay recognizable across hundreds of generations, weeks of production, and multiple teammates on the same project. Most people who attempt this hit a wall fast: the face drifts, the hair restyles itself, the eye color shifts a shade. The cause is almost never the model in isolation. It is that the workflow was never set up to enforce identity at every step. Consistency is a property of the canvas, not of any single render.

This guide walks the five steps in order — lock the reference, build the character sheet, go reference-to-video, hold multi-shot identity, and upscale to 4K — and shows how the Martini canvas turns each step into wired nodes instead of a folder-naming discipline you have to remember. The signature move is the same throughout: keep one character reference pinned and wire it into every node, so the reference-to-video handoff (Flux Kontext face into Vidu, Kling, or OmniHuman) happens in one place.

Text-to-image and text-to-video models do not "remember" a character. Each generation re-derives a face from the prompt and a random seed, so two runs of the same prompt produce two related-but-different people. The more generations you stack, the wider the identity spread. This is the core reason an AI character drifts: there is no persistent identity unless you supply one as an image reference on every single run.

The most common mistake amplifies the problem: chaining references through derived takes. You generate shot one, like it, and use it as the reference for shot two; then shot two seeds shot three, and so on. Each hop introduces a small drift, and small drifts compound. Over twenty shots, the cumulative error is visibly a different person — same haircut, different bone structure. The fix is to always reference the canonical source, never the last result you happened to like.

The second mistake is editing the whole frame when you only meant to change one thing. Re-prompting a generation model for a new outfit re-rolls the face along with the clothes, because the model regenerates the entire image. The professional pattern is surgical: change the outfit with a targeted edit model that preserves everything else. That is exactly what Flux Kontext is for, and it is the backbone of step two.

Start with one detailed character description in text: age range, build, ethnicity, hair color and style, eye color, distinguishing features (a freckle, a scar, a particular jawline), and signature wardrobe. Specificity is leverage. "Mid-thirties woman, athletic build, dark brown hair in a low ponytail, hazel eyes, small mole above the left eyebrow, charcoal cashmere sweater" is workable. "Beautiful young woman" is not — it gives the model nothing to hold constant.

Drop a Nano Banana 2 image node, paste the description, and generate four to six front-view takes. Pick the strongest as your canonical front view and pin it in the version tray. This pinned image is now the source of truth: every downstream node references it, never replaces it. Nano Banana 2 is the canvas's strongest character model precisely because it accepts multiple image references and stabilizes identity around them.

For face preservation when you change anything, reach for Flux Kontext rather than re-prompting. "Flux kontext face preservation" is a literal search query because Kontext edits only the region you target — swap a jacket, fix a stray hand, recolor a background prop — while the face, hair, and pose stay locked. On the canvas, wire a Flux Kontext node downstream of the chosen Nano Banana 2 take, mask the region to change, and prompt only that change. The identity you locked in step one survives every edit, which is the whole point of locking it first.

A character sheet is the minimum reference set that defines your character at every angle and expression you will need downstream. Duplicate the Nano Banana 2 node four times. In each duplicate, wire the canonical front view in as a reference and prompt for an additional view: three-quarter left, three-quarter right, profile, and a smiling close-up. Pin the strongest take from each. Five canonical references — front, three-quarter left, three-quarter right, profile, smiling close-up — is the minimum library to start.

For more demanding work — an AI-influencer feed, a recurring spokesperson, a brand mascot — expand the sheet to ten or fifteen seeds covering more outfits and more emotional expressions. To build the outfit variants without touching the face, run each base take through a Flux Kontext node and swap only the clothing region. Same character, ten outfits, all derived from one identity-locked base. This is the production backbone of any character-driven content feed: a small, curated sheet that the whole project generates against.

Once the sheet exists, every new shot is a multi-reference generation, not a fresh text-to-image gamble. Drop a Nano Banana 2 node for the new scene, wire in three or four sheet images chosen for the shot (front plus three-quarter for face anchoring, smiling close-up if the scene needs that expression, a full-body reference for wides), and write the prompt as action and environment first, then explicit attribution — "referencing image 1 for face and hair, image 2 for outfit, proportions following image 4." Be explicit about which reference governs which attribute and the model will follow you.

Image-side consistency is the prerequisite for video consistency. Without a stable sheet, your video drifts frame to frame and shot to shot. With one, the reference-to-video models that respect image input strongly will hold identity through motion. The reference-to-video handoff is the heart of the workflow: the same character references that anchored your stills now anchor your clips, so you never re-establish the face from scratch when you move from image to video.

Three video nodes do most of the work. Vidu is the fast-iteration choice when you want many reference-driven character clips quickly. Kling 3 — and especially Kling Avatar for dialogue — is the pick for character-driven shots with subtle performance and lip-sync. OmniHuman is the audio-driven talking-head model: feed it a character still plus a voice track and it animates a convincing performance from a single reference image. For each shot, wire one or two sheet images into the video node, choose them for the angle and expression the shot needs, and write the motion prompt as a single take with one clear action.

For talking-head episodes, the cleanest chain is a Nano Banana 2 still into Kling Avatar or OmniHuman, with the dialogue track coming from an ElevenLabs or Fish Audio node on the same canvas. Avatar and OmniHuman handle lip-sync; the pinned still holds the face. Because every Avatar node references the same image library, a recurring spokesperson looks like the same person across every episode even when the script and scene change. That is "character consistent production" — identity is shared infrastructure, not something you re-fight per clip.

Maintaining identity across a multi-shot sequence is where most tools quietly fail, because they treat each shot as an isolated job. The rule that keeps a character consistent across multiple shots is the same one from step one, applied at sequence scale: every shot references the canonical sheet directly, never the previous shot. On the Martini canvas this is structural — pin the sheet once, then wire those same pinned references into every image and video node in the sequence. No shot ever seeds the next.

This is the Martini wedge. Single-tool workflows solve consistency inside one model or one generation; the moment you cross from an image edit to one video model to a second video model, you lose the thread. On one canvas, the same character reference is wired into a Flux Kontext edit, a Vidu clip, a Kling shot, and an OmniHuman talking head simultaneously — the fan-out pattern. Run a prompt across several models at once, keep every take in the version tray, and compare them against the identical reference. Identity holds across image edits, multiple image-to-video models, and multi-shot sequences because the reference is the one shared constant.

Editability is the deeper payoff. Update the canonical front view and every downstream node re-renders against the new reference. Swap the wardrobe in Kontext and every video node downstream picks up the new outfit. Reorder a sequence by re-wiring. Character consistency stops being a battle you fight every shot and becomes a property of how the canvas is wired — which is also why a teammate opening the project sees the same sheet, the same pins, and generates against the same identity with no separate file structure to maintain.

Resolution is the last step, not the first. Generate and lock identity at the model's native resolution, choose the hero frames that nailed the character, then upscale only those. "4K consistent character rendering" is a real long-tail query, and the workflow that wins it is simply consistency first, upscale last: never chase 4K before the face is locked, because upscaling a drifted take just gives you a sharper wrong person.

On the canvas, wire a chosen consistent take into an image-upscale node (Topaz and Magnific are both available) to take a hero portrait to 4K with clean skin, hair, and fabric detail. For video, send a locked clip through a video-upscale node to finish a hero shot at 4K without re-rolling motion. Because the upscale node sits downstream of an already-consistent take, the identity you protected through four steps carries straight into the high-resolution master.

Keep the sheet curated as the project runs. Three to four references per generation is the sweet spot; a fifty-image library passed eight at a time loses the precision that makes the reference workflow worth it. Pin new canonical references as a new outfit or expression becomes signature, retire weaker takes, and let the next round generate against the tightened set. The library is a living document, and the canvas is its single source of truth.

Outside a canvas-based tool, character consistency is a discipline problem solved by spreadsheets, file naming, and remembering which version of which image is the "real" one. Most teams give up halfway and settle for "close enough." On the Martini canvas, consistency is a structural property of the workspace — the sheet is pinned, every node references it, the version tray remembers every take, and the fan-out pattern lets one reference drive many models at once.

The result is a single graph that spans the whole workflow this guide describes: lock the face with Nano Banana 2 and Flux Kontext, build the sheet, fan the reference into Vidu, Kling, and OmniHuman, hold identity across every shot, and upscale the heroes to 4K — with NLE export downstream so the consistent sequence leaves the canvas as a finished cut. No downloads, no re-uploads, no external editor between steps. That end-to-end wiring is the reason character-consistent production lives on one canvas instead of across five disconnected tools.