Unreal Canvas is a shared workspace where you work with agents to create and refine content using Unreal Engine (UE) and the other connected tools. You can work inside UE or in a supported standalone client, starting with a prompt, reference media, or a sceme om n Unreal scene.
The canvas brings references, generated results, notes, and reusable processes into one place. You work synchronously in Unreal Canvas to generate and refine images, videos, and 3D models from the scene in a project that you’ve already started.
Every element on a canvas is readable by both you and AI models. Your agents use the supported content and tools available. Arrange references and notes to provide context, then describe the task. The agent’s available models, tools, and permissions determine what it can do; arranging content alone does not guarantee that work will run automatically. Every step is visible and traceable, and you decide what gets approved.
For scene-based work, UE can send viewport captures, render passes, selected assets, and spatial annotations to Unreal Canvas. Supported results can be imported into the content browser or placed in a level through the editor’s tools.
In a typical local setup, the Unreal Canvas server runs on your computer, and serves the web-based client shown in the editor tab. The client is also available through supported app configurations.
Unreal Canvas is not related to the experimental Canvas asset, or to the Canvas Panel widget in UMG.
Unreal Canvas in Unreal Engine
Installation instructions are supplied with the UE build or plugin package. The integration includes these plugins:
| Plugin | What it does |
|---|---|
Unreal Canvas Bridge | This is the hub. It installs and launches the server, shows the Unreal Canvas tab, provides the canvas's editor tools, and adds the cutout actor. Turning the bridge on also turns on Unreal Canvas Spatial Annotations, and its required plugins:
The exact dependencies vary by platform and build. |
Unreal Canvas Spatial Annotations | This plugin adds the 3D Annotation panel for marking regions and actors with prompts. It also works without Unreal Canvas Bridge. |
To access Unreal Canvas, open the main tab from Tools > Unreal Canvas, or select Unreal Canvas on the Level Editor toolbar.
Builds that include Unreal Canvas (Native) expose a separate native editor surface. This overview describes the Unreal Canvas web-based tab. Not all controls or workflows are identical on the native surface.
What Gets Installed
The Bridge manages the Unreal Canvas server and can use configured build locations or a download source. On Windows, the plugin declares Python packages that the editor might need to install, requiring network access.
The Download additional Unreal Canvas components dialog lists optional downloads, their sizes, and installation locations. Review the list before downloading. Features that depend on a missing component or local model remain unavailable until their requirements are met.
To learn how to connect model providers, see Getting Started with Unreal Canvas.
How the Unreal Canvas and Editor Exchange Data
The editor can supply:
Viewport renders and their supported image passes.
Level Sequence renders as supported movie formats or image-frame output.
A live viewport stream, including supported color, depth, normal, and object-mask data.
Selected content browser assets.
Spatial annotation prompts, groups, and screen-position data, together with applicable overlays and masks.
Unreal Canvas can use editor tools to:
Create image cutout actors that face the viewport.
Import supported mesh, image, and Gaussian splat files into the content browser.
Place supported assets in a level.
Import supported rigged files as skeletal meshes.
Render object-reposition sequences using retained scene-state data.
Importing an asset and placing it in a level are separate operations unless the chosen tool explicitly combines them. Generative output is assigned to a card that may retain a model’s setup, graph, or script; not every generated card contains a graph.
What Changes in Your Project
| Change | Details |
|---|---|
Server startup | Bridge attempts to start the server during editor startup, before the tab is opened. Availability depends on the configured build and installation. Download-based build sources can also check for compatible versions. |
Unreal MCP | The Bridge ensures that the editor MCP server is available and registers its editor tools. |
Rendering | Quick Render uses play-in-editor (PIE) by default, so level behavior such as physics and Blueprint logic can run. Where supported, Editor World mode renders the loaded editor world without starting PID. |
Console operations | Available editor tools can execute console commands or change console variables. |
Downloads and telemetry | Configured build sources can use the network. Optional components have a download-consent dialog. Usage telemetry forwarded through editor analytics follows that analytics system’s availability and consent settings. |
Imported and generated assets | The current import default is /Game/Merlin, and native generated assets retain that root for compatibility. Examples include Cutouts/Generated and Splats/Generated. The product name is Unreal Canvas; these literal storage paths have not all been renamed. |
Render files | Sequence-render output is stored under Saved/UnrealCanvasSequenceRender. Retained scene-state files can be stored under Saved/UnrealCanvasSceneState. Rendering can consume significant disk space. |
Cutouts | Cutout actors save with the level and are supplied by an editor-only plugin module. Review or remove editor-only actors before cooking a level for a packaged build. |
Actor annotations | Annotating an actor can enable custom depth and assign a stencil value. Removing the annotation turns custom depth off and resets that value to zero; it does not restore an earlier custom stencil setup. |
Settings | Project configuration and per-user settings have different scopes. Team defaults are shared through the relevant configuration files; changing a local user setting does not automatically update every teammate. |
Files outside the project | Downloaded builds and optional components use configured installation locations. Build search paths and AI-model paths can point to other local or shared storage. |
How Unreal Canvas Works
There are three complementary ways of working Unreal Canvas:
| Work Surface | Description |
|---|---|
Toolshelf | Select a generation tool, prompt your AI agent and provide the required inputs. Results generated appear as cards or decks. |
Graph | Define a repetitive process by connecting typed nodes inside a graph. Inspect its inputs, intermediate operations, and outputs. |
Agent | Describe an outcome and ask an agent to prepare or run work using the available tools. Provide references and review any required approvals. |
The Toolbox contains reusable scripts, graphs, and other supported tools. The Agents panel provides a way to work with your agents and reopen conversations. Select Ask the agent on a card or from the canvas context controls to include canvas content in a request.
Keep the Unreal Canvas client that owns active work open. Closing that client can interrupt its canvas tools and scripts. Multiple clients can share a server, but a running script can remain tied to the client that started it. Editor operations also require the intended Unreal Editor connection.
Work with Toolshelf
For a scene-based image-generation workflow:
Select Image and a model that supports reference images.
Add the render passes you want to use through Inputs or the model’s input boxes. When the model accepts the inputs, use starting settings to alter the look of the output: Beauty, Depth, and Normal.
Write a prompt describing the desired change. For example, a lighting treatment, material, mood, or subject. Include any details you want the model to preserve.
Select an aspect ratio or output size that suits the shot, if the model exposes that setting.
Open the output options beside Generate and select where the results should go.
Set the number of results where supported, then select Generate or press Ctrl + Enter while working in the toolshelf.
Select Operations to follow the running graph or script and review each completed result .
Reference material is not mandatory for every task. Some models generate from text alone; others require images, video, meshes, or other inputs. The selected model determines which inputs and settings apply.
Output Options
| Option | Description |
|---|---|
Create New Card | Creates new output on the canvas while retaining the current inputs and settings. |
Create New Deck | Appears when the output count calls for multiple results grouped as a deck. |
Add to Deck | Adds results to an available destination deck. |
Add to Deck > From Batch | Routes each batch result to its input card’s deck. Batch inputs taken from files create new cards. |
Agent Chooses | When available, provides a way for the agent to select a new card or destination deck based on the request. |
Batch Mode
Turn on Batch mode to run one setup across multiple inputs. Add the inputs to the Batch field and check the planned run count.
Select Add to Deck > From Batch for results associated with each input card’s deck. File inputs produce new cards instead. You can also select an available output destination appropriate to the task.
Batch runs can make multiple provider calls. Check the model, output count, and service pricing before starting a large batch.
Work in a Graph
A graph contains nodes and connections that define a process. Graphs can contain nested graphs and other supported script nodes. On a canvas, the graph is represented by a card. Pipeline wiring belongs inside the graph.
Create a graph, select a reusable graph from Toolbox, or open a graph-backed card by selecting Open Graph.
Follow the connections between input nodes, processing steps, and outputs. Check the pin types, such as image, video, mesh, text, or number.
Supply the graph’s inputs through its exposed controls. Connect typed pins inside the graph to define how data moves through the process.
Select Run or Re-run to execute the intended graph or output path. Select Edit to change inputs or settings; opening settings alone does not run generation.
Select Operations to inspect results. A run can target a specific part of a graph, so completion does not mean every possible output was produced.
Iterate using the controls offered by the card. If the graph is locked, unlock it or edit a copy as appropriate. Keep earlier takes when comparing changes.
Save a reusable copy to Toolbox when the graph is ready to use in other work.
Canvas cards are created without pipeline wiring. Supply their media through the toolshelf or card inputs rather than trying to connect new wires between cards on the outer canvas.
Execution can reuse eligible cached results. An explicit Run or Re-run can still force part of a graph to generate again, even when its settings are unchanged.
Canvases
A canvas is where your work is laid out. A project has one root canvas and can contain multiple subcanvases. Each open root canvas has its own tab. A canvas holds cards, organizational regions, and annotations such as drawings and notes.
Frames
Frames group related cards in a region of the canvas. Frames summarize their contents, including review status, authors, teams, and recent changes. This helps you track a group of concepts or deliverables without inspecting every card separately.
Subcanvases
Subcanvases are the working areas nested inside another canvas. Its card previews the contents; open a subcanvas to work inside it. Subcanvases can contain more subcanvases when you need additional organization.
A subcanvas is not a deck with a pinned hero result. Use a deck when you want a group of alternatives represented by one chosen face card.
Canvas Tools
Canvases use Tool and Utility cards you add to a canvas, as well as the nodes inside Action cards. Canvas tools include:
Tool cards: Authored content with built-in options, such as Text Boxes, Comment Boxes, Image Grids, and Prompt Conditioning. These aren’t generation tools.
Utility cards: Reusable controls, such as a button that tidies the canvas or sends work for review.
Nodes: These live inside Action cards, not on the canvas itself.
Generation tools: The Toolshelf and Toolbox panel are separate places where you can work.
Cards
A card is a single element or artifact on the canvas that represents content, outputs, processes, or organizational containers on a canvas. Every card has a card type (how it behaves) and a content type (what it holds: image, video, mesh, audio, animation, and so on). Cards don’t have versions. A version is its own card, so generating a new result creates a new card.
On canvas surfaces, generated alternatives appear as separate cards, often grouped in a deck. Nodes inside a graph can retain their own version history.
Generated cards retain the setup steps or process that produced them. Creating another take preserves the earlier result. Editing authored content, notes, or tool settings follows the relevant editor’s behavior. Not every edit creates a new card.
Card Types
| Option | Description |
|---|---|
Action | Content produced by a process, such as a model, graph, or Python script. A model Action can retain the saved setup steps without containing a graph. Available controls let you inspect or reuse the process where supported. |
Deck | A group of cards presented through a pinned face card. Pin a different member to change the displayed result. Decks can hold alternatives and nested groups; members can be moved out. |
Component Card | Contains the parts of one deliverable, such as an output with related passes, masks, or other derived content. It keeps the parts associated with their originating work. |
Component | An individual part derived from another card. Its originating process is reached through the appropriate root card. Supported extraction actions create independent copies rather than detaching the original part. |
Reference | Imported media or content copied from another card. Derived references normally retain the captured result. Eligible references can optionally follow later changes to their source. |
Tool | Authored content or a direct editing tool, such as a text or timeline card. Its own controls determine how the content is edited. |
References and Source Links
A reference made from a card keeps the result captured when it was created. Where supported, turn on its source link to follow later changes, such as a new take or a different pinned deck face. Turning the link off keeps the currently displayed content.
Some derived content, including crops and grabbed video frames, cannot follow a source by replacing itself with the source’s full output. Use the source-navigation control to find the original where that relationship is available.
Imported files, Unreal asset references, and copied canvas outputs can have different update behavior. Do not assume that all references automatically stay live.
Card Toolbar
Selecting or hovering on a card shows its toolbar beneath it, subject to the current view and zoom. The bar combines actions and viewing controls, separated by a divider. Available buttons depend on the card’s content and capabilities.
| Option | Description |
|---|---|
Download | Downloads the available output. |
Edit | Opens the card’s editing controls. For generated media, it restores the saved prompt, model, inputs, and settings in the toolshelf. Other cards can open script inputs or their own settings. Opening Edit does not generate a result. |
Run / Re-run / Stop | Runs the card, creates another take where supported, or stops an active run. Select the control to run the action. Provider charges depend on the service used. |
Open Graph / View Script / Edit Script | Opens the available graph or script behind the card. A model’s setup steps do not necessarily have a graph to open. |
Source Controls | Navigate to a reference source or control its live link where supported. |
Grid / Carousel | Changes how a group of cards or supported version history is displayed. |
Open Viewer | Opens a larger content view. Select multiple compatible cards to compare their outputs. |
Capture and crop controls appear for supported media. Live source cards offer their relevant playback, capture, pause, and stop controls.
Pinning and deck expansion controls remain in the card header. Select Inspector for information about the selected card, its provenance, and review metadata.
Edit settings and regenerate is the generated-media editing tooltip. After changing the settings, start generation explicitly.
Work with a Card
Select Open Viewer to inspect media at a larger size, or Open Graph to inspect an available graph.
Double-clicking the card of a subcanvas opens its contents. Double-clicking authored-content cards opens an editor.
A common image-to-mesh workflow is:
Isolate the object you want to use in an image.
Select a compatible mesh-generation model and supply the required image or views.
Generate the mesh and inspect the result in Open Viewer.
Select Import to Content Browser, then select a content folder and asset name.
Place the imported asset in the level using the appropriate editor tool.
Render or capture the updated scene to continue iterating.
The import control is available in the viewer for supported content. Selecting Download on the standard card toolbar saves the output as a file.
Editors and Generation Tools
Viewers and editors provide a way to inspect or edit supported content directly, without first constructing a graph. Available controls depend on the media type and any installed extensions.
Toolshelf Generation Categories
| Option | Description |
|---|---|
Image | Generates images from text and, where supported, reference images or other controls. |
Video | Generates or transforms video using the inputs supported by the model, such as text, reference images, start/end frames, or video. |
Mesh | Generates 3D content from supported inputs, commonly a single image or multiple views. |
Splat | Generates Gaussian splat content through compatible services. |
Audio | Generates audio through compatible models. |
Text | Generates text through compatible models. |
Not every category or model is available in every setup. The configured providers, catalog, project restrictions, and installed services determine what you can select.
Toolbox
Toolbox finds reusable processes. The built-in collection includes:
| Option | Description |
|---|---|
Viewport Render | Renders the viewport using supported passes, including Beauty, Depth, Normal, and Edges. Annotation-related output is available when applicable. |
Viewport Snapshot | Captures an image of the current viewport. |
Sequence Render | Renders a Level Sequence using the supported render settings and output formats. |
Modify Viewport (Spatial) | Uses spatial annotations to guide changes to a rendered view. |
Graphs and scripts execute processes. Agent skills and instructions guide the agent’s approach and do not necessarily create a result card on their own.
Mesh Route
Select a mesh model according to its supported inputs and controls:
Single-image routes build a clear view of the intended object from one image. This also helps define the subject.
Multiview routes have several views. The number, ordering, and naming of views depend on the model.
Routes with additional controls exposes options such as topology or face count. These controls do not guarantee production-ready geometry.
Inspect topology, scale, materials, textures, and performance before using a generated mesh in production.
To import a supported mesh:
Open it in the viewer and select Import to Content Browser.
Select the content folder and asset name.
Unrigged meshes generally import as Static Meshes; supported files containing skin data import as skeletal meshes.
Review a replacement destination carefully if a destination already exists. Replacing an existing asset can affect instances that use it.
Viewer and Editing Tools
| Option | Description |
|---|---|
Segmentation | Uses supported local segmentation models to identify regions and create masks or derived content. Required model files must be installed. |
Markup and annotations | Add drawings or numbered marks to communicate intended changes. |
Comparison | Uses the viewer’s supported comparison layouts to inspect multiple outputs. |
Spatial annotations | Place prompts and color-grouped annotations in the Unreal level to guide scene-based changes. |
External editors | Open supported content in a configured external application and use its integration to bring edited work back. |
Auto-rig
Provide a mesh to Auto-rig, or ask an agent to rig a suitable selected asset. The built-in local route uses SkinTokens, and requires its model files, runtime, and supported GPU environment. Other registered rigging services can have different requirements.
Import the rigged output as a skeletal mesh and inspect the skeleton and weights before animating it. Rig quality depends on the input and selected model.
Extensions
Extensions add capabilities such as custom nodes, tools, editors, panels, workspaces, and integrations with other software. A team can author an extension for a specific workflow, with agent assistance where appropriate.
An extension’s installed tools and declared capabilities determine what it adds. Installing an extension does not imply that every associated model, credential, or external application is already configured.
The Unreal Canvas Agentic Pipeline
Ideation Phase and Planning
Unreal Canvas accelerates the development and refinement of your art assets and world building by skipping monotonous steps. The canvas tools generate decks of alternative styles and looks to choose from. This avoids wasted time developing one look you might abandon later.
An agent can help prepare the process, choose compatible tools, or organize results. Review its proposed work and respond to any required execution approvals.
Each run is billed. For more billing information, see Canvas Cost and Production Considerations.
Iteration and Refinement
Unreal Canvas supports quality control processes as part of the art pass. Change the mood or scene and carry those generated looks across versions, or by editing one marked object. Use a selected result as a reference for the next task. Describe what should change and what should remain recognizable. For example:
Keep the subject and explore a different material or lighting treatment.
Use a style reference while changing the subject.
Apply a change to one marked region or spatial-annotation group.
Restyle a sequence while using supported scene-derived controls to guide the motion and composition.
These inputs guide the model. They do not guarantee that only the requested region changes or that all scene geometry, camera motion, and identity are preserved exactly.
Render Passes
A render can provide several representations of the same scene. Related outputs can be kept together as parts of a deliverable.
| Option | Description |
|---|---|
Beauty | The rendered appearance, including color, materials, and lighting. |
Depth | Distance information that can help guide layout and spatial structure. |
Normal | Surface direction and form. |
Edges | Silhouettes and visible boundaries. |
Spatial annotation output | Applicable annotation overlays, masks, and prompts associated with marked areas. |
Beauty, Depth, and Normal are useful for compatible image workflows. Add other passes when the selected model supports them and they help communicate the task.
Sequence rendering can provide time-varying scene information as supported movie or frame output. Use only the control inputs accepted by the chosen video model. Depth, Beauty, and Edges can guide different aspects of the result, but none of these universally locks layout, occlusion, facial expression, or camera behavior.
Limits of Unreal Canvas
Results vary by model, input, and settings. Keep earlier takes for comparison.
A fixed card version can improve repeatability for some models, but identical settings do not universally guarantee an identical result. Re-running a saved card’s setup steps could bypass the face card of a deck to produce another take.
Maintaining the same character or environment across different shots can require additional work.
Generated meshes and rigs may need cleanup before final use.
Model availability depends on provider configuration, project restrictions, and installed dependencies.
Reviewing Agent Work
When an agent asks for a review, badges and colored outlines mark actors in Level Editor viewports, and assets get badges in the content browser. If you don't see these in your viewport, press G to leave Game View. Reviewing your work doesn't change your level, assets, or selection.
On the Unreal Canvas feedback card, select Approve, Request changes, or Reject, optionally add a Rating and a note, then send it. To decide later, select Close and save for later.
The review communicates a decision. Selecting Reject does not undo the agent’s changes. Inspect the actual content before approving it, and handle any desired rollback as a separate operation.
Select the Agents panel to return to a conversation. Select Ask the agent on a card includes that card as task context; do not assume it is the same operation as reopening the exact conversation that produced the result.
Unreal Canvas vs Unreal MCP
Unreal Canvas and Unreal MCP serve complementary purposes.
| Area | Unreal Canvas | Unreal MCP |
|---|---|---|
Purpose | A workspace for creating, organizing, inspecting, and refining content with connected tools and agents. | A protocol interface that exposes editor tools to compatible clients. |
Interface | Canvas cards, decks, frames, toolshelf, viewers, graphs, and agent conversations. | A client connection to the editor’s available toolsets. |
Typical outcome | Media and other content, together with process context and organized results. | Editor operations performed by the requested tools. |
Extensibility | Graphs, scripts, extensions, workspaces, and configured services. | Additional supported toolsets and client integrations. |
Setup | Configure the app/editor integration and any required providers, models, or local components. | Turn on the required editor toolsets and use the configuration appropriate to the chosen MCP client. |
Use the connection and access instructions for your exact engine build and client. A configuration file for one MCP client is not necessarily the correct format for another. Unreal Canvas uses editor connectivity for relevant operations while separately managing its media-generation services and agent connections.
Costs and Production Considerations
Costs
Costs depend on the selected service and provider, not on the name of the card action.
Cloud image, video, mesh, audio, text, and agent services can incur charges according to the provider’s pricing and your account arrangement.
Batch mode and Re-run can issue additional service calls. Check the model and expected run count before starting a large job.
Agent usage can have costs separate from the media-generation services it invokes.
Eligible cached work can be reused, but explicit Run or Re-run may force a selected generation or output path to execute again. An unchanged graph is not a guarantee of a free run.
Production Considerations
Consider the following when using Unreal Canvas as part of your production process:
Confirm content rights, provenance labeling, provider terms, and data handling with your legal and production teams.
Evaluate generated output for its intended use rather than assuming that a successful generation makes it production-ready.
Confirm the support and release status of the version you plan to use before scheduling production work around it.
Watch your machine’s computational power, memory, and storage. Local rendering and installed local processing do not incur a cloud-provider generation fee.