> For the complete documentation index, see [llms.txt](https://help.intangible.ai/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://help.intangible.ai/learn-more/concepts/image-reference.md).
# References
The single biggest lever for professional fidelity. Bind a reference image to a 3D object and the visualizer locks the rendered look across every shot – the same character, vehicle, or product, consis
Attach a photograph to a 3D object and the visualizer renders that object as the thing in the photo, in every shot.
## What is an image reference?
An image reference in Intangible is a photograph attached to a specific 3D object in your scene. At render time, the visualizer locks that object's appearance to the photograph, so the output shows the actual thing in the picture rather than the model's generic interpretation. For agency work, image references are non-negotiable: a 2024 Bronco needs to render as a 2024 Bronco, a Lululemon storefront as a Lululemon storefront, an iPhone-and-not-a-generic-phone as the SKU you're advertising.
If you take one workflow away from these docs, take this one.
## Image Reference vs LoRA vs Custom Style
Intangible has three ways to lock visual consistency: image references, LoRAs and custom styles. Each serves a different job.
| | Image Reference | LoRA | Custom Style |
| ---------------------- | ------------------------------------ | ---------------------------------------------------------------- | --------------------------------------- |
| Scope | One specific object | One object, model-level bias | Whole render, every shot |
| Controls | What this object looks like | A learned style or character bias | Project-wide brand treatment |
| Setup | Drop in a photo | Train or download `.safetensors` or `.pt` | Upload references in Visualize, save |
| Best for | Brand-true product, hero with photos | Illustrator style, internal aesthetic, characters without photos | Brand- or campaign-wide look |
| Cross-shot consistency | Yes, automatic | Varies with training | Yes, automatic |
| Plan requirement | All plans | All plans | All plans |
| Reach first when | Almost always start here | Can't capture the look in a single photo | The style is bigger than any one object |
For most agency briefs, Image Reference is the first reach. LoRAs and custom styles layer on top when the job needs them. See [LoRAs](/build/loras.md) and [Custom styles](/visualize/custom-styles.md) for the deeper coverage.
## Why this is the headline lever
A diffusion model handed a text description of a chair generates *a* chair. A diffusion model handed an image of the actual rattan-and-teak chair the agency is pitching renders *that* chair. The text-only chair is sometimes useful. The referenced one is useful every time.
A reference image gives the model the visual truth of one specific object. It unlocks three production cases:
* **Branded assets and products with custom geometry.** Logos, store fronts, uniquely shaped products, deeptech hardware – anything the model can't be expected to know without a picture. The reference image is what closes the gap from "looks like the brief" to "is the brief".
* **Cross-shot character consistency.** A hero with a reference image renders the same face, costume, and silhouette across every shot in the project. Without reference, the model treats each generation as independent and the character drifts.
* **CAD plus hero photo.** Bring the client's actual CAD as the 3D mass via [Smart Import](/build/import-your-own-models.md). Attach a hero photograph as the image reference. The model gets both: structural truth from the mesh, surface truth from the photo.
## Four ways to get one onto an object
### 1. Through the Object Details panel (manual)
Select the object in the viewport and click the Details icon on its toolbar. **Edit Model Details** opens over the scene (**Edit Group Details** for a group). In the **Reference images** row, click **Upload Images** or **Media Library**. JPEG, PNG and WebP are accepted; GIFs are not. Quality beats quantity: one excellent image of the most important or most bespoke component does more for the render than a dozen mediocre angles. Quantity has a ceiling as well: a scene render sends at most 10 reference sheets, and each model caps how many input images it takes.
On the canvas, a 3D model placed in a scene holds the same reference images in its **Details**, with **Select from Canvas** to pick image cards straight off the canvas. See [Groups and cards](/canvas/groups-and-cards.md).
### 2. In the chat (conversational)
Asking in the chat panel is the fastest path. In Build mode, click **+** in the chat panel to attach the photo, then type:
> Use this image as the reference for the chair.
The agents find the matching object in the scene and attach the reference, and the chat panel confirms the attach so you know it landed. The Build-mode viewport doesn't preview the reference itself: the object stays greyboxed and picks up a base color at most. The reference resolves at render time, whether the agents render on the canvas or you render in Visualize.
Ask in the chat panel when you can name the object ("the red couch", "the lamborghini").
### 3. Generate one in Studio
When the object is invented rather than real, there's nothing to photograph and nothing in the client's brand folder to pull from. Generate the reference sheet in place instead of building it in an external tool and uploading it.
Select the element, open its details from the toolbar, then click **Generate Reference Sheet** (the sparkle icon) in the Reference images row. The **Generate Reference Sheet** dialog opens with the prompt already filled in from the object's name, plus its description if it has one; the empty field reads *Add details*. You can add reference images, pick the model, and on some models the resolution. Edit the prompt, click **Generate**, and the dialog closes while a **Generating sheet** tile holds the slot.
Write what the thing is, plainly. "the US space shuttle" and "a green tiled kitchen island" are both the right shape of prompt: they name the subject and leave the rest alone.
Describe whatever the object needs to look like. It doesn't have to be a character or a turnaround sheet: "a green tiled kitchen island" is a perfectly good prompt, and what comes back is an image of that.
An **Image generation completed** toast confirms it, and the sheet attaches to the selected element with a **Generated** badge. The generated image also lands in your media library with the same **Generated** badge, so you can attach it to another object from **Media Library**.
Generating costs credits, the same as any other generation. See [Credits and tokens](/learn-more/concepts/credits-and-tokens.md).
{% hint style="info" %}
Describe the thing, not a mood. "Orange tree" is thin enough that the model fills the gaps for you. "Orange tree, mature, heavy fruit load, gnarled trunk" gets you the tree you meant. The same specificity that makes a good prompt anywhere else applies here.
{% endhint %}
Generated references are ordinary references once they land. Everything below about what attaches do, what overrides what, and how many to attach applies to them unchanged.
### 4. Paste from the clipboard
Copy an image to the clipboard, select the object, and paste with `Ctrl V` / `⌘ V`. The image uploads, attaches to the selection as a reference, and lands in the media library, the same path as clicking **Upload**. The Upload button's tooltip says as much: *Upload Images (or paste from clipboard)*. The Details panel doesn't need focus, so pasting works with the viewport focused.
Paste several images at once and all of them attach. Only images are picked up, and anything else on the clipboard is left alone. Let one paste finish before you start the next, because a paste that arrives while an upload is still in flight is ignored.
**Render the real product, not a generic one.**
Try image references in Intangible
## References on a group or a set
An image reference doesn't have to attach to a single object. Attach one to a **group** or a **set** and it anchors the whole collection to a subject and a style: *make this room, object, or collection look and feel like this*.
A group reference stays attached through the work. Save the group as a set, copy it, paste it, or reuse it in another project later, and the style direction travels with it, so you don't re-explain it each time.
Reach for a group reference when:
* **The look belongs to the collection, not the object.** A material language or visual mood covering a whole set piece, rather than one chair in it.
* **A reusable set has to stay consistent across projects.** The reference is part of the set, so it arrives with it.
* **The style is easier to show than to describe.** Attaching an image beats rewriting the same paragraph of prompt on every render.
Reference sheets are built per group *and* per entity, so a set can carry its overall direction while individual objects inside it keep their own specifics.
A worked example: attach a reference image to a dining-room set, then generate. The visual direction is baked into the set instead of being re-argued in the prompt every time.
To attach a group reference, select the group and click the Details icon on its toolbar, or right-click it in the Outliner and pick **Edit Details**. **Edit Group Details** has the same Reference images row.
## What attaches actually do
```mermaid
flowchart LR
A[3D object in scene] --> B[Object name + description]
A --> C[Image reference attached]
B --> D[Visualizer Subjects block]
C --> D
D --> E[Diffusion model]
E --> F[Render that honors the reference]
```
An object in the scene carries its 3D geometry, a text description and an image reference. A new camera on the same scene reads all of it again, so the object stays right from every angle. A flat render has none of that to hold onto, which is why editing one tends to drift from shot to shot.
A scene render uses up to 10 reference sheets, one per referenced subject in the camera's view. Subjects outside the frame do not count toward the 10. Objects that take their references from their group share one sheet.
The visualizer's auto-prompt picks up references at prompt-build time. The Subjects block of the prompt mentions that the object has a reference image. At generation, the model receives both the prompt text and the image. See [How the visualizer thinks](/learn-more/concepts/how-the-visualizer-thinks.md) for the deeper flow.
## What overrides what
Three layers stack, each overriding the one below:
1. **The 3D object** – the base. Its geometry and position are the source of truth for shape and placement.
2. **The image reference** – sits on top of the geometry and defines what the object's surface looks like.
3. **The final prompt** – wins over both.
The catch is that the object's **name** feeds the final prompt. Name an object "Gulfstream G550" and the model reaches for its own idea of a G550 and overrides the livery you attached as a reference. Keep the name – and any prompt text – generic ("private jet", not "Gulfstream G550") so the reference image is what defines the look. A specific name is the most common reason a reference seems like it "isn't being applied".
## When to reach for it
The signal for an image reference is consistent: a generation has the right composition but the wrong specifics.
* **Right place, wrong car.** The vehicle is positioned correctly, the angle is right, the environment is right – but it's a generic mid-sized SUV instead of the actual model in the brief.
* **Right pose, drifting face.** The character is at the right scale and the right pose, but the face is changing shot-to-shot.
* **Right product silhouette, generic surface.** The shape and proportion are right, but the materials, finishes, or branding are off.
Re-prompting won't fix any of these, because the model has no spatial truth to work from and has to invent one. Attach the reference and the next render comes back resolved.
## Tips that level up the result
{% hint style="info" %}
**Vanilla object names beat descriptive ones for character consistency.** "Mark" and "Jeff" hold their look across renders better than "pirate captain" and "British sailor", because descriptive names pull the model toward generic interpretation and away from the specific reference image. The webinar covers this directly around the 18-minute mark.
{% endhint %}
{% hint style="info" %}
**Multi-view references give better mesh-aware results.** Front, three-quarter, and side photographs of the same object produce more consistent renders than a single photograph from one angle. Use the multi-image slot when you have them.
{% endhint %}
{% hint style="info" %}
**Build mode doesn't preview the reference.** Attaching a reference doesn't repaint the greyboxed object to look like the photo. The viewport may show a base color, but the reference itself only resolves at render time. Don't wait for the viewport to "look right" before generating – attach the reference, then render to see it applied.
{% endhint %}
{% hint style="info" %}
**For imported CAD, pick reference images that match the shots you plan to render.** Mix close-ups with the camera angles you expect in the final video. A reference set heavy on macro detail won't help the model on a wide tracking pass; a set of only side profiles falls apart on a three-quarter render. Pick the photos you're confident will appear on screen.
{% endhint %}
{% hint style="info" %}
**A render you like can become a reference.** Download a strong Intangible render, crop the component you want to lock in an external editor like Photoshop, and attach the crop as an image reference – or as a [custom style](/visualize/custom-styles.md) – to hem the model in on the next pass.
{% endhint %}
## Limits
* **Image reference doesn't override composition.** A reference image of a car doesn't tell the model where to put the car – the 3D scene does. Reference is for *what* the object looks like, not *where* it goes.
* **Model fidelity to references varies.** Some image models are tuned for reference-image conditioning; older video models honor references less tightly. See [Models](/visualize/ai-models.md) for which models in the current working set honor references most tightly. If a reference seems to be ignored, try a different image model first; if the result is still off, the reference may need to be sharper.
* **Sub-megapixel images are fine; multi-megapixel adds nothing.** Every image reference is downsampled to a **720 × 1024 sheet** before the visualizer hands it to the model, regardless of source size. A clean 1024 × 1024 file and a 4000 × 4000 file land at the same effective resolution. If an object has multiple reference images attached, they're consolidated onto a single 720 × 1024 sheet at the same step (front, three-quarter, and side angles composited together rather than passed in separately).
## Further viewing
Phil walks through image reference in the AI You Can Direct webinar (55 minutes; the pirate-scene segment around the 18-minute mark covers reference images directly).
{% embed url="" %}
## Related
* [Object details](/build/object-details.md) – manual attachment via the Details panel.
* [What the agents do in Build](/chat-agents-intangible/in-the-modes.md#build) – conversational attachment via natural language.
* [How the visualizer thinks](/learn-more/concepts/how-the-visualizer-thinks.md) – how attachments reach the prompt.
* [Smart Import](/build/import-your-own-models.md) – CAD + reference image is the canonical client-product workflow.
* [Generate 3D Asset](/build/generate-3d-asset.md) – generates the mesh from the same reference image.
* [LoRAs](/build/loras.md) – the alternative when a fine-tuned model is required.
---
# Agent Instructions
This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com.
## Querying This Documentation
If you need additional information that is not directly available in this page, you can query the documentation by asking a question.
Perform an HTTP GET request on the following URL with the `ask` and `goal` query parameters:
```
GET https://help.intangible.ai/learn-more/concepts/image-reference.md?ask=&goal=
```
`ask` is the immediate question: it should be specific, self-contained, and written in natural language.
`goal` is what the user is ultimately trying to achieve, the reason they need the answer. Sharing it helps GitBook give you a better, more relevant answer. A goal is most helpful when it describes the outcome the user wants rather than restating the question. For example, with `ask=how do I create an API token`, a goal like `automate deployments from our CI pipeline` lets GitBook tailor the answer to that use case.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.
Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.