September 1, 2026AIExplore

How to Create Consistent Characters in Luma

Use @character with uploaded references in Dream Machine to keep identity, wardrobe, and presence consistent across shots.

Luma

Character consistency in Dream Machine starts with a reference image and the @character syntax. Official best practices: upload your image, then type @character followed by your prompt so appearance stays coherent across shots. Ray3 Modify also describes character reference in Modify and Keyframes workflows for paid subscribers. Confirm live UI in your account. Start at /explore/luma.

This guide covers the workflow in detail. Related Luma articles: /blog/how-to-control-style-and-aesthetics-in-luma, /blog/how-to-edit-and-refine-videos-iteratively-in-luma, /blog/how-to-build-campaigns-and-reusables-in-luma.

When this workflow is the right job

Use @character when the same person or mascot must recur across a sequence. Prefer @style when you need aesthetic DNA without identity. Prefer Modify when a good clip needs a small change.

Step by step workflow

1. Capture a clean reference

Choose a clear face or full body still with readable wardrobe and lighting you can repeat.

Scenario:
A realistic luma workflow is being prepared for Use Luma Dream Machine for Text-to-Video using luma. The starting requirement is: Reference QA [ ] Face or body readable [ ] Wardrobe distinct [ ] Neutral enough lighting [ ] No heavy occlusion. The work should be tested on a representative input first so the result can be reviewed before the same process is applied to the full project or production workload.

Objective:
Create a production-ready result for "Reference QA [ ] Face or body readable [ ] Wardrobe distinct [ ] Neutral enough lighting [ ] No heavy occlusion" that directly supports the article use case. The output should be specific, reviewable, and reproducible rather than a generic demonstration. Keep the requested goal as the primary outcome and avoid adding unrelated features, assumptions, or unsupported capabilities.

Inputs:
Use the actual source material required for this task, together with the intended audience, destination, format, and quality requirements. Specify relevant files, text, URLs, structured data, reference assets, dimensions, language, tone, timing, model or generation settings, credentials, field mappings, or integration values when they apply. Keep secrets out of the example and use the product's supported credential or configuration mechanism.

Workflow:
1. Start with one representative input that contains the important characteristics of the real workload.
2. Configure luma specifically for the requested task and make the important settings explicit.
3. Run the first pass and inspect the result against the objective.
4. Correct only the settings or source material responsible for a failed requirement instead of changing everything at once.
5. Validate the intermediate result before passing it to the next step.
6. When the result meets the requirements, save the successful configuration so the same process can be repeated consistently.
7. If this is a multi-step workflow, verify each handoff and keep a clear fallback or review path for failures.

Requirements:
The example must use supported functionality only. Do not invent product features, pricing, limits, integrations, model names, API behavior, or unavailable settings. Preserve important source data and formatting. Validate required fields before processing, handle empty or invalid input explicitly, prevent accidental duplicate processing where relevant, and stop or route the item for review when a required step fails. For credentials, use the supported secure configuration rather than placing secrets directly in the content.

Expected output:
The final result should directly satisfy the "Reference QA [ ] Face or body readable [ ] Wardrobe distinct [ ] Neutral enough lighting [ ] No heavy occlusion" requirement and be understandable without guessing what was supplied or configured. A successful run should produce the intended output in the requested format, with the important values and workflow decisions clear enough to reproduce the result. If the workflow can fail, the expected behavior should also make the failure visible and provide a clear next action instead of silently producing an incomplete result.

2. Prompt with @character

Upload the image, type @character, then describe action and scene.

Scenario:
A realistic luma workflow is being prepared for Use Luma Dream Machine for Text-to-Video using luma. The starting requirement is: @character A woman in a flowing red dress walks through a sunlit Victorian garden, camera tracking from the side, golden hour lighting, gentle movement.. The work should be tested on a representative input first so the result can be reviewed before the same process is applied to the full project or production workload.

Objective:
Create a production-ready result for "@character A woman in a flowing red dress walks through a sunlit Victorian garden, camera tracking from the side, golden hour lighting, gentle movement." that directly supports the article use case. The output should be specific, reviewable, and reproducible rather than a generic demonstration. Keep the requested goal as the primary outcome and avoid adding unrelated features, assumptions, or unsupported capabilities.

Expected output:
The final result should directly satisfy the "@character A woman in a flowing red dress walks through a sunlit Victorian garden, camera tracking from the side, golden hour lighting, gentle movement." requirement and be understandable without guessing what was supplied or configured. A successful run should produce the intended output in the requested format, with the important values and workflow decisions clear enough to reproduce the result. If the workflow can fail, the expected behavior should also make the failure visible and provide a clear next action instead of silently producing an incomplete result.

3. Keep wardrobe language stable

Repeat the same clothing descriptors across shots. Change only setting or action.

Scenario:
A realistic luma workflow is being prepared for Use Luma Dream Machine for Text-to-Video using luma. The starting requirement is: @character Same woman in the flowing red dress sits on a garden bench reading, static medium shot, golden hour lighting, gentle leaf movement.. The work should be tested on a representative input first so the result can be reviewed before the same process is applied to the full project or production workload.

Objective:
Create a production-ready result for "@character Same woman in the flowing red dress sits on a garden bench reading, static medium shot, golden hour lighting, gentle leaf movement." that directly supports the article use case. The output should be specific, reviewable, and reproducible rather than a generic demonstration. Keep the requested goal as the primary outcome and avoid adding unrelated features, assumptions, or unsupported capabilities.

Expected output:
The final result should directly satisfy the "@character Same woman in the flowing red dress sits on a garden bench reading, static medium shot, golden hour lighting, gentle leaf movement." requirement and be understandable without guessing what was supplied or configured. A successful run should produce the intended output in the requested format, with the important values and workflow decisions clear enough to reproduce the result. If the workflow can fail, the expected behavior should also make the failure visible and provide a clear next action instead of silently producing an incomplete result.

4. Tighten framing when needed

If anatomy drifts, move closer or regenerate variants. Use Modify with character reference when available on paid plans.

Scenario:
A realistic luma workflow is being prepared for Use Luma Dream Machine for Text-to-Video using luma. The starting requirement is: Tighten to medium close up. Natural hand positioning if hands are visible. Keep red dress and hair length.. The work should be tested on a representative input first so the result can be reviewed before the same process is applied to the full project or production workload.

Objective:
Create a production-ready result for "Tighten to medium close up. Natural hand positioning if hands are visible. Keep red dress and hair length." that directly supports the article use case. The output should be specific, reviewable, and reproducible rather than a generic demonstration. Keep the requested goal as the primary outcome and avoid adding unrelated features, assumptions, or unsupported capabilities.

Expected output:
The final result should directly satisfy the "Tighten to medium close up. Natural hand positioning if hands are visible. Keep red dress and hair length." requirement and be understandable without guessing what was supplied or configured. A successful run should produce the intended output in the requested format, with the important values and workflow decisions clear enough to reproduce the result. If the workflow can fail, the expected behavior should also make the failure visible and provide a clear next action instead of silently producing an incomplete result.

Practical @character prompts

Garden walk

Bench read

Scenario:
A realistic luma workflow is being prepared for Use Luma Dream Machine for Text-to-Video using luma. The starting requirement is: @character Same woman in the flowing red dress sits on a garden bench reading, static medium shot, golden hour lighting.. The work should be tested on a representative input first so the result can be reviewed before the same process is applied to the full project or production workload.

Objective:
Create a production-ready result for "@character Same woman in the flowing red dress sits on a garden bench reading, static medium shot, golden hour lighting." that directly supports the article use case. The output should be specific, reviewable, and reproducible rather than a generic demonstration. Keep the requested goal as the primary outcome and avoid adding unrelated features, assumptions, or unsupported capabilities.

Expected output:
The final result should directly satisfy the "@character Same woman in the flowing red dress sits on a garden bench reading, static medium shot, golden hour lighting." requirement and be understandable without guessing what was supplied or configured. A successful run should produce the intended output in the requested format, with the important values and workflow decisions clear enough to reproduce the result. If the workflow can fail, the expected behavior should also make the failure visible and provide a clear next action instead of silently producing an incomplete result.

Cafe entrance

Scenario:
A realistic luma workflow is being prepared for Use Luma Dream Machine for Text-to-Video using luma. The starting requirement is: @character Young man in a navy jacket enters a cafe, medium tracking shot from the side, soft morning light, calm pace.. The work should be tested on a representative input first so the result can be reviewed before the same process is applied to the full project or production workload.

Objective:
Create a production-ready result for "@character Young man in a navy jacket enters a cafe, medium tracking shot from the side, soft morning light, calm pace." that directly supports the article use case. The output should be specific, reviewable, and reproducible rather than a generic demonstration. Keep the requested goal as the primary outcome and avoid adding unrelated features, assumptions, or unsupported capabilities.

Expected output:
The final result should directly satisfy the "@character Young man in a navy jacket enters a cafe, medium tracking shot from the side, soft morning light, calm pace." requirement and be understandable without guessing what was supplied or configured. A successful run should produce the intended output in the requested format, with the important values and workflow decisions clear enough to reproduce the result. If the workflow can fail, the expected behavior should also make the failure visible and provide a clear next action instead of silently producing an incomplete result.

Studio portrait move

Scenario:
A realistic luma workflow is being prepared for Use Luma Dream Machine for Text-to-Video using luma. The starting requirement is: @character Subject turns head slightly toward camera, soft wrap light, locked medium close up, neutral grey backdrop.. The work should be tested on a representative input first so the result can be reviewed before the same process is applied to the full project or production workload.

Objective:
Create a production-ready result for "@character Subject turns head slightly toward camera, soft wrap light, locked medium close up, neutral grey backdrop." that directly supports the article use case. The output should be specific, reviewable, and reproducible rather than a generic demonstration. Keep the requested goal as the primary outcome and avoid adding unrelated features, assumptions, or unsupported capabilities.

Expected output:
The final result should directly satisfy the "@character Subject turns head slightly toward camera, soft wrap light, locked medium close up, neutral grey backdrop." requirement and be understandable without guessing what was supplied or configured. A successful run should produce the intended output in the requested format, with the important values and workflow decisions clear enough to reproduce the result. If the workflow can fail, the expected behavior should also make the failure visible and provide a clear next action instead of silently producing an incomplete result.

Raincoat street

Scenario:
A realistic luma workflow is being prepared for Use Luma Dream Machine for Text-to-Video using luma. The starting requirement is: @character Person in a yellow raincoat walks a wet night street, slow tracking, neon reflections, gentle handheld feel.. The work should be tested on a representative input first so the result can be reviewed before the same process is applied to the full project or production workload.

Objective:
Create a production-ready result for "@character Person in a yellow raincoat walks a wet night street, slow tracking, neon reflections, gentle handheld feel." that directly supports the article use case. The output should be specific, reviewable, and reproducible rather than a generic demonstration. Keep the requested goal as the primary outcome and avoid adding unrelated features, assumptions, or unsupported capabilities.

Expected output:
The final result should directly satisfy the "@character Person in a yellow raincoat walks a wet night street, slow tracking, neon reflections, gentle handheld feel." requirement and be understandable without guessing what was supplied or configured. A successful run should produce the intended output in the requested format, with the important values and workflow decisions clear enough to reproduce the result. If the workflow can fail, the expected behavior should also make the failure visible and provide a clear next action instead of silently producing an incomplete result.

Chef kitchen

Scenario:
A realistic luma workflow is being prepared for Use Luma Dream Machine for Text-to-Video using luma. The starting requirement is: @character Chef in white coat plates pasta, side tracking shot, warm practical lights, shallow depth of field.. The work should be tested on a representative input first so the result can be reviewed before the same process is applied to the full project or production workload.

Objective:
Create a production-ready result for "@character Chef in white coat plates pasta, side tracking shot, warm practical lights, shallow depth of field." that directly supports the article use case. The output should be specific, reviewable, and reproducible rather than a generic demonstration. Keep the requested goal as the primary outcome and avoid adding unrelated features, assumptions, or unsupported capabilities.

Expected output:
The final result should directly satisfy the "@character Chef in white coat plates pasta, side tracking shot, warm practical lights, shallow depth of field." requirement and be understandable without guessing what was supplied or configured. A successful run should produce the intended output in the requested format, with the important values and workflow decisions clear enough to reproduce the result. If the workflow can fail, the expected behavior should also make the failure visible and provide a clear next action instead of silently producing an incomplete result.

Runner dawn

Scenario:
A realistic luma workflow is being prepared for Use Luma Dream Machine for Text-to-Video using luma. The starting requirement is: @character Runner in grey kit jogs along a waterfront at dawn, tracking from the side, cool soft light, steady pace.. The work should be tested on a representative input first so the result can be reviewed before the same process is applied to the full project or production workload.

Objective:
Create a production-ready result for "@character Runner in grey kit jogs along a waterfront at dawn, tracking from the side, cool soft light, steady pace." that directly supports the article use case. The output should be specific, reviewable, and reproducible rather than a generic demonstration. Keep the requested goal as the primary outcome and avoid adding unrelated features, assumptions, or unsupported capabilities.

Expected output:
The final result should directly satisfy the "@character Runner in grey kit jogs along a waterfront at dawn, tracking from the side, cool soft light, steady pace." requirement and be understandable without guessing what was supplied or configured. A successful run should produce the intended output in the requested format, with the important values and workflow decisions clear enough to reproduce the result. If the workflow can fail, the expected behavior should also make the failure visible and provide a clear next action instead of silently producing an incomplete result.

Musician practice

Scenario:
A realistic luma workflow is being prepared for Use Luma Dream Machine for Text-to-Video using luma. The starting requirement is: @character Guitarist in a denim shirt practices on a stool, static medium shot, soft window light from left.. The work should be tested on a representative input first so the result can be reviewed before the same process is applied to the full project or production workload.

Objective:
Create a production-ready result for "@character Guitarist in a denim shirt practices on a stool, static medium shot, soft window light from left." that directly supports the article use case. The output should be specific, reviewable, and reproducible rather than a generic demonstration. Keep the requested goal as the primary outcome and avoid adding unrelated features, assumptions, or unsupported capabilities.

Expected output:
The final result should directly satisfy the "@character Guitarist in a denim shirt practices on a stool, static medium shot, soft window light from left." requirement and be understandable without guessing what was supplied or configured. A successful run should produce the intended output in the requested format, with the important values and workflow decisions clear enough to reproduce the result. If the workflow can fail, the expected behavior should also make the failure visible and provide a clear next action instead of silently producing an incomplete result.

Teacher classroom

Scenario:
A realistic luma workflow is being prepared for Use Luma Dream Machine for Text-to-Video using luma. The starting requirement is: @character Teacher in a soft blue sweater writes on a whiteboard, slow push in, bright classroom light.. The work should be tested on a representative input first so the result can be reviewed before the same process is applied to the full project or production workload.

Objective:
Create a production-ready result for "@character Teacher in a soft blue sweater writes on a whiteboard, slow push in, bright classroom light." that directly supports the article use case. The output should be specific, reviewable, and reproducible rather than a generic demonstration. Keep the requested goal as the primary outcome and avoid adding unrelated features, assumptions, or unsupported capabilities.

Expected output:
The final result should directly satisfy the "@character Teacher in a soft blue sweater writes on a whiteboard, slow push in, bright classroom light." requirement and be understandable without guessing what was supplied or configured. A successful run should produce the intended output in the requested format, with the important values and workflow decisions clear enough to reproduce the result. If the workflow can fail, the expected behavior should also make the failure visible and provide a clear next action instead of silently producing an incomplete result.

Traveler pier

Scenario:
A realistic luma workflow is being prepared for Use Luma Dream Machine for Text-to-Video using luma. The starting requirement is: @character Traveler with a canvas backpack walks a pier at blue hour, tracking side angle, muted cool grade.. The work should be tested on a representative input first so the result can be reviewed before the same process is applied to the full project or production workload.

Objective:
Create a production-ready result for "@character Traveler with a canvas backpack walks a pier at blue hour, tracking side angle, muted cool grade." that directly supports the article use case. The output should be specific, reviewable, and reproducible rather than a generic demonstration. Keep the requested goal as the primary outcome and avoid adding unrelated features, assumptions, or unsupported capabilities.

Expected output:
The final result should directly satisfy the "@character Traveler with a canvas backpack walks a pier at blue hour, tracking side angle, muted cool grade." requirement and be understandable without guessing what was supplied or configured. A successful run should produce the intended output in the requested format, with the important values and workflow decisions clear enough to reproduce the result. If the workflow can fail, the expected behavior should also make the failure visible and provide a clear next action instead of silently producing an incomplete result.

Dancer studio

Scenario:
A realistic luma workflow is being prepared for Use Luma Dream Machine for Text-to-Video using luma. The starting requirement is: @character Dancer in black rehearsal wear moves across a studio floor, wide static shot, soft overheads.. The work should be tested on a representative input first so the result can be reviewed before the same process is applied to the full project or production workload.

Objective:
Create a production-ready result for "@character Dancer in black rehearsal wear moves across a studio floor, wide static shot, soft overheads." that directly supports the article use case. The output should be specific, reviewable, and reproducible rather than a generic demonstration. Keep the requested goal as the primary outcome and avoid adding unrelated features, assumptions, or unsupported capabilities.

Expected output:
The final result should directly satisfy the "@character Dancer in black rehearsal wear moves across a studio floor, wide static shot, soft overheads." requirement and be understandable without guessing what was supplied or configured. A successful run should produce the intended output in the requested format, with the important values and workflow decisions clear enough to reproduce the result. If the workflow can fail, the expected behavior should also make the failure visible and provide a clear next action instead of silently producing an incomplete result.

Barista pour

Scenario:
A realistic luma workflow is being prepared for Use Luma Dream Machine for Text-to-Video using luma. The starting requirement is: @character Barista in an apron pours latte art, medium lock off, warm cafe lights, steam visible.. The work should be tested on a representative input first so the result can be reviewed before the same process is applied to the full project or production workload.

Objective:
Create a production-ready result for "@character Barista in an apron pours latte art, medium lock off, warm cafe lights, steam visible." that directly supports the article use case. The output should be specific, reviewable, and reproducible rather than a generic demonstration. Keep the requested goal as the primary outcome and avoid adding unrelated features, assumptions, or unsupported capabilities.

Expected output:
The final result should directly satisfy the "@character Barista in an apron pours latte art, medium lock off, warm cafe lights, steam visible." requirement and be understandable without guessing what was supplied or configured. A successful run should produce the intended output in the requested format, with the important values and workflow decisions clear enough to reproduce the result. If the workflow can fail, the expected behavior should also make the failure visible and provide a clear next action instead of silently producing an incomplete result.

Cyclist stop

Scenario:
A realistic luma workflow is being prepared for Use Luma Dream Machine for Text-to-Video using luma. The starting requirement is: @character Cyclist in a red jersey stops at a quiet intersection, static medium, late afternoon light.. The work should be tested on a representative input first so the result can be reviewed before the same process is applied to the full project or production workload.

Objective:
Create a production-ready result for "@character Cyclist in a red jersey stops at a quiet intersection, static medium, late afternoon light." that directly supports the article use case. The output should be specific, reviewable, and reproducible rather than a generic demonstration. Keep the requested goal as the primary outcome and avoid adding unrelated features, assumptions, or unsupported capabilities.

Expected output:
The final result should directly satisfy the "@character Cyclist in a red jersey stops at a quiet intersection, static medium, late afternoon light." requirement and be understandable without guessing what was supplied or configured. A successful run should produce the intended output in the requested format, with the important values and workflow decisions clear enough to reproduce the result. If the workflow can fail, the expected behavior should also make the failure visible and provide a clear next action instead of silently producing an incomplete result.

Librarian aisle

Scenario:
A realistic luma workflow is being prepared for Use Luma Dream Machine for Text-to-Video using luma. The starting requirement is: @character Librarian in a cardigan shelves books, slow push in, warm tungsten aisle lights.. The work should be tested on a representative input first so the result can be reviewed before the same process is applied to the full project or production workload.

Objective:
Create a production-ready result for "@character Librarian in a cardigan shelves books, slow push in, warm tungsten aisle lights." that directly supports the article use case. The output should be specific, reviewable, and reproducible rather than a generic demonstration. Keep the requested goal as the primary outcome and avoid adding unrelated features, assumptions, or unsupported capabilities.

Expected output:
The final result should directly satisfy the "@character Librarian in a cardigan shelves books, slow push in, warm tungsten aisle lights." requirement and be understandable without guessing what was supplied or configured. A successful run should produce the intended output in the requested format, with the important values and workflow decisions clear enough to reproduce the result. If the workflow can fail, the expected behavior should also make the failure visible and provide a clear next action instead of silently producing an incomplete result.

Painter loft

Scenario:
A realistic luma workflow is being prepared for Use Luma Dream Machine for Text-to-Video using luma. The starting requirement is: @character Painter in paint stained overalls studies a canvas, static medium, soft north window light.. The work should be tested on a representative input first so the result can be reviewed before the same process is applied to the full project or production workload.

Objective:
Create a production-ready result for "@character Painter in paint stained overalls studies a canvas, static medium, soft north window light." that directly supports the article use case. The output should be specific, reviewable, and reproducible rather than a generic demonstration. Keep the requested goal as the primary outcome and avoid adding unrelated features, assumptions, or unsupported capabilities.

Expected output:
The final result should directly satisfy the "@character Painter in paint stained overalls studies a canvas, static medium, soft north window light." requirement and be understandable without guessing what was supplied or configured. A successful run should produce the intended output in the requested format, with the important values and workflow decisions clear enough to reproduce the result. If the workflow can fail, the expected behavior should also make the failure visible and provide a clear next action instead of silently producing an incomplete result.

Hiker ridge

Scenario:
A realistic luma workflow is being prepared for Use Luma Dream Machine for Text-to-Video using luma. The starting requirement is: @character Hiker in a green shell stands on a ridge, slow orbit, golden hour, wind in jacket.. The work should be tested on a representative input first so the result can be reviewed before the same process is applied to the full project or production workload.

Objective:
Create a production-ready result for "@character Hiker in a green shell stands on a ridge, slow orbit, golden hour, wind in jacket." that directly supports the article use case. The output should be specific, reviewable, and reproducible rather than a generic demonstration. Keep the requested goal as the primary outcome and avoid adding unrelated features, assumptions, or unsupported capabilities.

Expected output:
The final result should directly satisfy the "@character Hiker in a green shell stands on a ridge, slow orbit, golden hour, wind in jacket." requirement and be understandable without guessing what was supplied or configured. A successful run should produce the intended output in the requested format, with the important values and workflow decisions clear enough to reproduce the result. If the workflow can fail, the expected behavior should also make the failure visible and provide a clear next action instead of silently producing an incomplete result.

Host welcome

Scenario:
A realistic luma workflow is being prepared for Use Luma Dream Machine for Text-to-Video using luma. The starting requirement is: @character Host in a charcoal blazer greets guests at a doorway, medium tracking, soft interior practicals.. The work should be tested on a representative input first so the result can be reviewed before the same process is applied to the full project or production workload.

Objective:
Create a production-ready result for "@character Host in a charcoal blazer greets guests at a doorway, medium tracking, soft interior practicals." that directly supports the article use case. The output should be specific, reviewable, and reproducible rather than a generic demonstration. Keep the requested goal as the primary outcome and avoid adding unrelated features, assumptions, or unsupported capabilities.

Expected output:
The final result should directly satisfy the "@character Host in a charcoal blazer greets guests at a doorway, medium tracking, soft interior practicals." requirement and be understandable without guessing what was supplied or configured. A successful run should produce the intended output in the requested format, with the important values and workflow decisions clear enough to reproduce the result. If the workflow can fail, the expected behavior should also make the failure visible and provide a clear next action instead of silently producing an incomplete result.

How to improve character consistency

Always upload a reference before expecting identity match. Text alone is weaker for faces.

Repeat wardrobe and hair descriptors every shot. Silent assumptions cause drift.

Keep related clips on one board for continuity.

Wide shots that need perfect fingers are risky. Frame hands out when they are non essential.

When hands must show, prompt natural positioning and generate variants.

Change only one story beat per shot: walk, sit, or turn, not all at once with new clothes.

Use Modify with character reference on paid Ray3 Modify workflows when official help shows those controls.

Prefer medium and medium close ups when facial identity is the priority.

Avoid swapping lighting recipes mid sequence unless the story requires a time jump.

Build a character card: age range, hair, wardrobe, and forbidden changes.

If identity slips, return to the strongest reference image rather than chaining weak outputs as new refs.

For mascots, lock silhouette language and color blocks as tightly as human wardrobe.

Prompting guidance that holds up in review

Prefix with @character after the upload, then state action, camera, and light in natural language.

Carry the same wardrobe phrase across the sequence like a locked prop list.

Combine @character with one camera move only so motion complexity does not fight identity.

Describe hand intent when hands are visible: resting, holding cup, at sides.

Keep age and hair length language stable unless the story needs a change.

Limitations to respect

Perfect finger and teeth detail is not guaranteed, especially in wide shots.

Modify character tools are described for paid subscribers in official Ray3 Modify help. Confirm your plan.

Chaining weak outputs as new references usually worsens drift.

Identity and heavy style changes in the same pass often conflict.

Field tips from real boards

Campaign work should store the reference asset with the prompt library.

Do not change face language and wardrobe in the same revise pass.

Review full motion, not a single frame, because expression flicker can hide in stills.

When using keyframes, ensure the character is present in the frames you modify per official Modify guidance.

Store the strongest reference still with the board so later shots do not inherit weak identity from a soft take.

Wardrobe language is a lock file. If collaborators rewrite clothing descriptors casually, identity drift follows.

Medium close ups protect faces better than wide establishing shots when the character is the brand.

When fingers fail, reframe rather than stacking more hand adjectives into the same prompt.

Keep lighting constants across a character sequence unless the story beat requires a time jump.

One story action per shot keeps @character from competing with costume and camera changes.

If Modify offers character reference on your plan, use it for small wardrobe preserving tweaks instead of full regenerations.

Review expression flicker in motion. A single still thumbnail can hide identity problems.

Store the strongest reference still with the board for later shots.

Wardrobe language is a lock file across the sequence.

Medium close ups protect faces better than wide establishing shots.

When fingers fail, reframe rather than stacking hand adjectives.

Keep lighting constants unless the story needs a time jump.

One story action per shot keeps identity from competing with costume changes.

Review expression flicker in motion, not only in thumbnails.

Return to the original reference if identity slips after a weak take.

Write a one line character card and paste it under every @character prompt in the sequence.

Avoid sunglasses and heavy occlusion in the reference if the face must remain the brand.

If hair length changes between takes, the audience reads it as a different person. Lock that detail.

Side tracking shots often preserve identity better than extreme low angles.

Generate three variants of the same beat and pick identity winners before advancing the story.

Do not use a stylized illustration as the only reference when you need photoreal continuity.

Keep props consistent when they define the character, such as a backpack or jacket color block.

For mascots, describe silhouette and color blocks as tightly as you would describe a face.

Common mistakes

Expecting identity without uploading a reference
Changing wardrobe and face descriptors together
Wide shots requiring perfect finger detail
Using weak outputs as new character refs
Multiple camera moves with character work
Skipping board continuity across a sequence

Related Luma articles: /blog/how-to-control-style-and-aesthetics-in-luma, /blog/how-to-edit-and-refine-videos-iteratively-in-luma, /blog/how-to-build-campaigns-and-reusables-in-luma. Return to /explore/luma for the broader guide set.