FLUX Kontext: Character Consistency Across Scenes
- Explain why character consistency across scenes is difficult with standard text-to-image generation
- Apply the scene-change instruction pattern using the local Kontext Dev workflow and a character reference image
- Describe the multi-image workflow using Image Stitch and Kontext Pro for stronger character identity lock
- Add a LoRA to the Kontext Dev workflow to combine trained character appearance with instruction-based editing
Why Character Consistency Is Hard
Text-to-image generation produces a slightly different version of your character every time, even with an identical prompt. The face shifts, the hair changes shade, the build varies. Over a series of twenty images representing the same character — a product mascot, a fictional protagonist, a recurring figure in a marketing campaign — these small differences accumulate into an inconsistent set that cannot be used together.
Standard solutions are imperfect. LoRAs help significantly but require training (covered in Lessons 6–8). Fixing a seed locks the composition, not just the character. IPAdapter (covered in ComfyUI Image Generation) provides style transfer but drifts on face identity. Each approach has a ceiling.
FLUX Kontext approaches the problem differently. Because it takes an existing image as input alongside an instruction, you can use a reference image of your character as the anchor and instruct the model to place that character in a new scene. The model's task becomes: "keep this person exactly as they look in the reference, change everything else." That is a fundamentally more direct constraint than trying to describe a character through text alone.
The Scene-Change Pattern (Local Dev)
The local Kontext Dev workflow from Lesson 1 accepts a single input image. For character consistency, that image is your character reference — the best, clearest image you have of the character you want to maintain across scenes.
The instruction pattern that produces reliable results looks like this:
- Start with what must not change: "Keep the woman's appearance exactly as shown — same face, brown shoulder-length hair, green eyes, denim jacket, and white shirt."
- Then describe the new scene: "Place her in a sunlit outdoor cafe in Paris, seated at a table with a coffee cup."
- Avoid changing anything about the character in the same instruction that changes the environment. Environment and character changes should be separate passes.
Running this produces the character in a new setting with their appearance preserved from the reference. The output then becomes the reference for the next scene variation. Each new scene builds from the previous output rather than from a fixed original, which keeps the character visually coherent across a long series.
One practical constraint of the local dev approach: it works from a single reference at a time. If your reference image shows the character from a specific angle, the model has limited information about how they look from other angles. This is where either iterating from multiple reference angles or switching to the multi-image Pro workflow makes a meaningful difference.
Choosing Your Reference Image
The quality of your starting reference determines everything downstream. A weak reference produces weak consistency. Here is what to look for:
- Clear, well-lit face with detail visible. Soft, blurry, or small faces give the model insufficient information to anchor identity. If you are generating a reference from scratch, generate at 1024px and ensure the face occupies at least 20% of the frame.
- Neutral or simple pose. A reference image where the character is sitting or standing naturally — not mid-action, not at an extreme angle — gives the model a stable baseline to work from. Extreme poses in the reference tend to bleed into output poses even when you have not asked for a pose change.
- Distinctive, specific clothing or colours. Characters are easier for Kontext to track when they have a recognisable visual signature — a specific jacket colour, a distinctive accessory, a unique hairstyle. Generic clothing and generic faces drift more across iterations.
- Consistent lighting. A reference shot with flat, even lighting is easier to transpose into new environments than one with heavy directional shadows, which the model tends to try to preserve even when the new scene has different light.
If you are generating the character from text rather than working from a photograph, invest time in finding the best version before starting scene iterations. Run 15–20 generations with different seeds, pick the one that best represents the character, and lock that as your reference. This upfront investment pays off across the whole series.
Building a Multi-Scene Series
Once you have a strong reference, the production workflow for a character series looks like this:
- Generate or select your master reference. This is the canonical version of the character. Save it separately from your output folder so it is not accidentally overwritten.
- Run the first scene change using the master reference as input and a scene-change instruction. Evaluate the output — does the character look right? If not, adjust the instruction (make the character description more explicit) rather than the scene description.
- Use the best output as a secondary reference for further scene changes if the first output looks better than the original in some specific way. Otherwise keep returning to the master reference to avoid drift.
- Keep the master reference in every new session. When you re-open ComfyUI and load a new scene, always load from the master reference rather than from the most recent output in a series. Each additional iteration step between the master and the current image compounds small changes.
Naming outputs consistently — something like character-name_scene-01.png, character-name_scene-02.png — makes it easy to compare the series and spot where drift began if it appears.
The Multi-Image Workflow (Kontext Pro)
Kontext Pro, available through ComfyUI's Partner Nodes (requires a Comfy account and credits), supports a multi-image input workflow that provides a stronger character anchor than the single-image local dev approach.
The workflow uses two nodes that do not exist in the local dev template:
- Load Image (multiple instances): Load two or three reference images of your character from different angles — front, three-quarter view, side. Each gets its own Load Image node.
- Image Stitch: Combines the loaded images side by side into a single wider image. Kontext Pro reads this stitched image as a multi-reference input, using all three views simultaneously to build a more complete model of the character's appearance.
- Flux.1 Kontext Pro Image: The Partner Node that performs the edit. Set the
aspect_ratioto match your desired output (not the stitched image's ratio), and write your scene-change instruction in thepromptfield. Leaveprompt_upsamplingoff when consistency matters — it rewrites your prompt for richer results but makes outputs non-reproducible.
Having two or three reference angles solves the main limitation of single-image consistency: the model can now reason about how the character looks from different positions, which produces more accurate results when the output pose differs from the reference.
The tradeoff versus the local dev approach: Pro is billed per generation in Comfy credits, and you are dependent on the BFL API being available. For production work where consistency is critical, the quality improvement is usually worth the cost. For exploration and iteration, the local dev approach is more economical.
Combining Kontext with LoRA
The strongest character consistency setup in ComfyUI combines FLUX Kontext Dev with a character LoRA. The LoRA provides a trained model of the character's appearance that the base model can draw on; Kontext provides the instruction-following editing capability. Together, they constrain identity from two directions simultaneously.
To add a LoRA to the Kontext Dev workflow:
- Insert a Load LoRA node between the Load Diffusion Model output and the KSampler model input.
- Connect the DualCLIP Load output through the same Load LoRA node (the Load LoRA node has both model and clip inputs and outputs).
- Set LoRA strength to 0.6–0.8. Stronger than 0.9 tends to override Kontext's instruction-following; weaker than 0.5 provides little additional benefit over Kontext alone.
- Include the LoRA's trigger word in your CLIP Text Encode instruction alongside the scene description.
This combination is covered in detail in Lessons 6–8, which walk through training character LoRAs from scratch. If you have an existing LoRA for your character from a previous project, it integrates into the Kontext workflow immediately with the steps above.
A note on stacking: LoRA + Kontext Dev is a local workflow with no per-generation cost. For a large series of scenes where budget matters, this is usually the preferred setup over Kontext Pro.
When to Use Each Approach
Matching the tool to the task avoids both under-investing in consistency (and getting drift) and over-investing (spending on Pro credits when local dev would have been sufficient):
- Kontext Dev, single image: Quick scene variations, exploration, low-stakes series, or any project where you want zero per-generation cost and can tolerate occasional minor drift. Best when your reference image is clear and distinctive.
- Kontext Dev + LoRA: Consistent character across a large series, production work, or any situation where the character needs to hold up across 20+ images. Requires upfront LoRA training time but no ongoing cost.
- Kontext Pro, multi-image: Maximum character fidelity, complex pose changes in output, or when you do not have or do not want to train a LoRA. The multi-angle reference input consistently produces the best identity lock. Billed per generation.
Lesson 3 moves away from character-focused editing and into a different Kontext capability: FLUX Fill and FLUX Depth, which give you precise control over which regions of an image to edit and how structural depth information guides the output.
- Using a reference image as input lets Kontext anchor the character's appearance — write what must stay the same first, then describe the new scene
- The local dev workflow takes a single input image; multi-image input (Image Stitch + multiple reference angles) requires Kontext Pro via Partner Nodes and Comfy credits
- Always return to the master reference image for each new scene rather than chaining from previous outputs — each additional iteration step compounds drift
- Adding a character LoRA at strength 0.6–0.8 to the Kontext Dev workflow provides two layers of identity constraint without any per-generation cost
- A distinctive reference image — clear face, specific clothing, neutral pose, even lighting — produces significantly more consistent results than a generic one
Progress is saved in this browser only — clear your cache or switch device and it's gone. Create a free account and it follows you everywhere.