The Media Gallery

The shared pin-board for images, video, and audio -- used across characters, locations, props, and shots.

The Media Gallery is a shared component that appears on the Media page of a character, location, prop, scene, shot, episode, experiment and the project. It's the place where all generated and uploaded media lives, and where you curate what gets used in production.

Think of it as a pin-board: you accumulate media, star the ones you like, choose the ones that count, and archive the rest.

Starring -- liking media

Starring marks an item as starred -- a bookmark meaning "I want to find this again later." Multiple items can be starred. A star is not an approval: the choices that count are the ones you make with Set as reference (a character, location or prop) and Set as storyboard / Set as rough clip / Set as finished clip (a shot).

Starred items float to the top of the gallery in Grid, List, and Graph views, so the ones you starred are always easy to find. The items you have chosen -- an asset's reference image, a shot's storyboard and rough clip -- are not pinned; star one if you want it at the top. When you want to use a starred item as an input to an operation, drag it from the gallery into the input field -- the star makes it easy to spot among many options.

Starring does not automatically wire an item into a workflow, and it does not mark anything as finished. It is a bookmark, not a selection. Different workflow steps might want different starred items from the same gallery.

Anything can be starred, and the star does not change what the item is. A gallery holds prompts, descriptions, dialogue and audio next to pictures, and an operation's output is often a prompt -- so the newest card in a character's gallery may well be text. Star it if it is the good one; nothing stops you.

What that means in practice: anything that goes looking for "this character's reference" asks for a picture specifically. If the only thing you have starred is a prompt, a shot that pulls in reference images will pass over it and use your newest image instead. And a readiness row that asks for reference images is satisfied only by an image you set as the reference -- a star alone never satisfies it. Likewise, an input that wants an image refuses anything that is not one -- drag a prompt onto an image slot and you get a message saying so, rather than a job that runs and comes out wrong.

Archiving -- setting media aside

Archiving is the opposite of starring: it pushes an item to the bottom of the gallery, marking it set-aside without removing it. The file stays in the gallery and in storage -- it is a curation signal ("not this one"), not a deletion. Delete is the separate, permanent action for when you want a file gone for good.

Linking media between galleries

A gallery can hold links to items that live in another entity's gallery -- for example, a character's reference image linked into a shot's gallery. This matters because an operation only takes inputs from the current gallery: you drag an item from the gallery into an input. Linking brings what the operation needs into the gallery it runs in, without copying the file.

To copy, move or link selected items to another gallery, select them and choose Copy, Move or Link from the gallery menu (or press C, M or L). The Organize panel opens with that verb already chosen; pick the destination in it, and press Done when you are finished. That Move moves exactly the items you chose; to take along the items that only feed them, and to have links and chosen pictures updated, use Move to... on an item's menu (see "Moving media to another gallery" below).

A link has to name the thing it points back at, so the two galleries that belong to no single entity -- the project-wide gallery and an episode's own gallery -- can be linked into but not out of. Copy or move from those instead.

Unlinking removes the link from this gallery only. It is Unlink on the item's menu in the Graph view; on a linked card in Grid and List the same job is done by Delete. The item still exists in its home gallery and in cloud storage -- nothing is deleted. (A character reference unlinked from a shot's gallery is untouched in the character's gallery.) Make Local Copy on a linked item turns the link into an item of this gallery's own. Go to linked media on a linked item opens the gallery the file really lives in -- the character's, location's, prop's, scene's, shot's or experiment's Media page -- with that item highlighted and scrolled into view in whichever display mode (Grid, List or Graph) that gallery is in, without opening it full screen. If the linked media has been deleted you are told so, and you stay on that gallery.

Things made in an experiment, or in the wrong place, end up in the wrong gallery. Move to... on an item's menu (on every card, in Grid, List and Graph; with several items selected it moves the whole selection) takes them somewhere else in the same project: the project gallery, an episode, a scene, a shot, a character, location or prop (the base or one of its looks), or an open experiment. New experiment... creates an experiment with the name you give it and moves the items into that, which is the quick way to tidy a mess into a place you can look through and delete.

The dialog does not move just the item. It reads where the item came from and sorts the rest of the gallery into three groups:

  • Only feeds this -- an input in the same gallery that nothing else uses. It is ticked, so it comes along; a chain of intermediate steps comes along with its final picture. Untick one to leave it behind.
  • Made from this -- items derived from something that is moving. They are not ticked; tick one to take it too (that can add more to the first group, because an input used only by things that are now moving has become free to go).
  • Also used elsewhere -- an input that something staying behind also uses. It stays, and the dialog says what uses it. Inputs that live in a different gallery are never moved; they stay referenced as they are.

Everything about an item goes with it: how it was made, its star, tags, thumbnail, whether it is archived, and its pose or camera angle name. Nothing is copied -- the files are shared by every gallery that lists them. Moving a pose or camera angle into a character or location look follows the same rule as naming one there: if the look has no preferred item for that name this one becomes it, and if it has one you choose whether to keep the current one or use the item you moved. Moving one out of a look hands the name to the next item that carries it.

Nothing is left pointing at the old place. A link to a moved item in another gallery is re-pointed, so Go to linked media still opens it. A picture chosen as an asset's reference image, a shot's storyboard or clips, or a recipe step's output is cleared when the item leaves the gallery it was chosen from -- the same thing deleting the item would do. Two uses stop a move altogether and say so: a picture used in a Blocking Set, and a clip on the episode timeline that reads the project gallery; change those first.

The whole move is saved at once, so it is all done or not done. The confirmation has Undo, which puts the items back as they were, including what was cleared. (A new experiment created for the move stays, empty.) The Assistant can do the same move: ask it to "tidy the leftovers from this experiment into a new experiment" and it applies the same rule, then tells you what came along and what stayed.

Leaving while a Cloud render finishes

A render you queue on Cloud does not need the page it was started from. OA's server finishes the job itself: it fetches the finished picture from Comfy Cloud with your key and saves it to the gallery, once, with its provenance, and marks the queue row done -- even if you closed every OA tab right after pressing Queue. Open the gallery later and it is there. A render that ran on your own computer is covered separately and needs Chrome to be running.

Trying things somewhere disposable

A gallery is a scratchpad, but it is a scratchpad that belongs to something: run four versions of an operation on George and George's gallery holds four trial pictures you did not want to keep. When the thing you are doing is answering a question -- which model, which settings -- do it in an experiment instead. An experiment has a gallery of its own, borrows its inputs as links so the originals are untouched, records the answer you reached, and is deleted afterwards. Anything worth keeping goes back into this gallery with Keep, and keeps working after the experiment is gone.

Select the tiles you want to work on and the gallery's actions offer New experiment from selection: you name the question, and the experiment opens holding every tile you selected, ready to try things on. From there Try, several models and several operations all live inside that workspace.

The Links button in the gallery controls is where you find the experiments about this entity -- and + New experiment there does the same thing, bringing your selection with it. The same dialog lists the relations the entity already holds: a shot's scene, cast, location and props; a scene's episode and shots; a character's looks.

View modes

The gallery has three view layouts:

Mode Use for
Graph Seeing how each item was made -- its ancestry. The richest view, and the one most people work in.
Grid Browsing thumbnails quickly
List Comparing metadata, dates, and tags

Graph view

The Graph view shows the ancestry of each media asset -- which operation and which input files produced it, tracing back through everything that ran before it. This is powered by the provenance data that OA stores when it routes a completed ComfyUI job to the gallery (see ComfyUI Integration). Use it to understand how a result was achieved, or to trace which source assets contributed to a final output.

When several outputs came from the same operation run, they share one operation box that fans out to each output -- so a step that produces one track per character, for example, appears as a single box rather than a duplicate per track. Audio items and operation boxes show the time the operation ran along the bottom.

Double-click any item in the graph to open it full screen. That includes the pale yellow text boxes -- the prompts and other written inputs an operation ran with. A text box on the canvas only has room for the first few words, so double-click it to read the whole thing, wrapped and scrollable, with a Copy text button in the corner. Press Escape or use the close control to go back to the graph. While an item is open full screen the page's address names it, so you can copy the address and send it: opening it shows the same item full screen. Copy text is also on the text box's own menu if copying is all you wanted.

Highlight cues

The same outline cues mean the same thing in Grid, List, and Graph views:

Cue Meaning
Solid blue outline The item is selected. Click an item to select it; Shift-click in Graph view adds an item and the files it was built from (that nothing else needs) so you can bulk-archive or delete a dead branch safely.
Dashed blue outline The item you last opened in fullscreen -- a reminder of "what was I just looking at?". It clears when you open a different item or reload, and is independent of selection.
Strong green border On a shot's gallery only: this item is the rough clip, the footage the shot plays until it has a finished clip. Hover it for the label.
Pale green border On a shot's gallery only: this item is the storyboard still, the picture the shot shows until there is a clip. Same colour, weaker, so the two read as a pair. An item that is both is marked as the rough clip.
Strong green border (character, location, prop) This item is the reference image -- the one picture that IS this character, location or prop. Hover it for the label. See the reference image.

Newest First is newest first, after the starred cards. The sort menu's top entry, Starred first, keeps the cards you starred at the front of the gallery whatever their date; the rest follow in the order you chose. The green-bordered cards -- the reference image, the storyboard still, the rough clip -- are not pinned: they sort by date like the rest, and you star one if you want it at the top. Untick Starred first and every card sorts by date. On a shot, tapping an empty input slot with nothing selected uses the green storyboard still or rough clip.

In Graph view, hovering an item adds extra tracing cues: the hovered item gets a yellow outline, the items that fed into it are marked in blue, and the items it fed into are marked in red, so you can see a node's inputs and outputs at a glance. An item whose right-click menu is open gets an orange outline.

The reference image

A character, location or prop can have one reference image: the picture that says what it looks like. Open an item's ... menu (or right-click it in Graph view, or use the flag button in fullscreen) and choose Set as reference. The item gets a strong green border so you can see which one it is; Remove as reference on the same item clears it. Choosing a different item moves the reference -- there is only ever one.

Wherever the app needs one picture of the asset, it uses the reference image first and falls back to your starred images (then the newest image) only when there is none:

  • the picture on the asset's card in the Characters, Locations and Props lists;
  • the stand-in picture on the timeline for a shot that has no media of its own yet;
  • the images linked into a shot's or scene's gallery from its cast, location and props;
  • the images a new look starts with, alongside the base's starred items;
  • the plan's "reference images available" check -- it is ready only once you have set a reference image. A star does not count: it only marks an image you starred.

The Assistant reads it too. Ask "what is George's reference image?" and it names it; ask it to repose George or put George in a scene and it uses that picture for the likeness. You can also ask it to change the reference ("make George's reference the upscaled cutout").

Each look has its own gallery, so each look has its own reference image. The character's own reference is its default look's. A look does not borrow the default look's reference -- set one on the look when you want the Assistant to know what that look looks like.

Any item can be the reference, whatever its type; archived items do not offer it.

Supported media types

Type Formats
Images PNG, JPG, WebP, GIF, SVG, BMP, TIFF
Video MP4, WebM, MOV, AVI, and others
Audio MP3, WAV, AAC, FLAC, M4A, and others
3D Models GLB
Text / References TXT, MD, external links

Getting media in

There are four ways to add an existing file to a gallery:

Route Use it for
Paste Copy an image anywhere -- a browser, a screenshot tool, another app -- click the gallery and press Ctrl+V (Cmd+V on Mac). The fastest route, and the only one that needs no file on disk.
Drag and drop Drop files from your file manager straight onto the gallery.
Upload Files From the gallery's options menu or the empty gallery. Asks where the files are coming from -- this computer, or Google Drive.
Paste from Clipboard The same as pressing Ctrl+V, from the options menu -- use it if your browser blocks the keyboard shortcut.

Pasting accepts images, video, audio, and text. When you copy an image from a web page the clipboard also carries the page text and the image's address; the gallery takes the picture.

Dropping an item that is already in the project

Those four routes bring a file in. An item that is already somewhere in this project is a different thing: dropping one on a gallery asks Link or copy? rather than uploading anything.

This is how you move a picture the Assistant just showed you into the gallery it belongs in -- every thumbnail in a reply can be dragged out of the chat panel. Link shows the original and shares its file; Copy makes an entry of its own, which is what you want for something whose source is about to go away, such as an experiment result. The Link button is unavailable, with the reason on hover, where a link cannot be written -- nothing links out of the project gallery, an episode gallery or an experiment. Dropping an item on the gallery it already lives in does nothing.

Dragging an item onto a destination in the Organize panel is the same pair of transfers with the verb chosen in advance; see Linking media between galleries above.

Uploading from Google Drive

Choose From Google Drive at the Upload action and OA opens your Drive. The first time, you sign in with Google and allow read access to your files; after that the same sign-in is reused, including the one you may already have granted for a screenplay document.

You can open folders, search by name, and tick as many files as you like -- ticks are kept as you move between folders, so one trip can collect files from several places. Only files a gallery can hold are listed: images, video, audio and 3D models. Google Docs, Sheets and Slides are not media, so they are not offered.

Each file you tick is fetched and added on its own, keeping the name it had in Drive, and reporting its own progress. If one file cannot be read, you are told which one; the rest still arrive.

Getting media out

Download on an item's "..." menu saves that one file to your computer. It works for images, video and audio alike, and it is on every gallery.

The file is saved under the name the gallery shows for that item -- its description, or the name you gave it, or "Generated by workflow" -- with the original file type kept. Nothing is saved under the long jumble of letters and numbers OA stores files under internally, so a folder of downloads still tells you what each file is.

Generating media

Every gallery generates AI media from its right-hand panel, and there is one way to work: the Recipe panel.

Press Choose an operation. What opens is a list of things you might want done, grouped the way you would ask for them:

  • Make an image -- from a description, from references, from another image
  • Change an image -- repaint part of it, extend it, enlarge it, cut the subject out
  • Prepare an input -- crop it, read a pose out of it, describe it in words
  • Make a video -- animate a still, transfer a pose, lip-sync a line
  • Voice and music -- speak a line, clone a voice, compose a track

A table of contents of the five groups sits above the list, with how many kinds of operation each one holds. Press one and it opens and scrolls there -- a user who wants a video should not have to scroll past everything else to find video. Each group can be collapsed to get it out of the way.

Under each group are the operations themselves -- Image to Video, Text to Image, and so on -- and under each operation, one card per model. The model is the real choice: it is the name you heard about, and it is what decides how the result looks, what it costs and whether it will run on your machine. Pick a card and that operation's form opens in place: fill in its inputs, press Queue (with Local or Cloud beside it saying where it runs; an operation that runs inside OA has Run instead), and the result lands back in the gallery. The operation's name heads the form -- it reads Remove Background (RMBG), so it names the model as well as the job -- with the facts about what you chose on the line beneath it. The facts are three short lines -- the model build, whether it runs locally, and whether Comfy Cloud can run it -- and the description under them folds to two lines with Read more.

A recipe of several operations shows each as a step card: a title row with the step's number and operation and the expand / collapse button at its right end, collapsed except the one you are on. One row above the cards names the recipe, holds Run all, and has a ... menu (Edit a copy, Rename, Choose another recipe, Use this recipe for the step, Load the recommended recipe). Choose another recipe opens a searchable dialog of every recipe you can use: the other ways to make the same thing first, then your project's own recipes, then all the rest. When one step's input is fed by an earlier step, the input says Filled from step 1's output when it finishes; you change what feeds it by changing its input. See The Recipe panel.

That heading is the one control: press it and the list opens again, on the operation you are already using, with every model for it in view. Switching model is one click on another card.

There is a search box for finding an operation by name, and the whole list can be narrowed by what an operation takes as input or which model it uses.

What a model card tells you

Every card in the list is the same card, at the same size, in every section -- Recently used and the models under each heading alike. Each one carries, at a glance:

  • the operation and the model, together: Remove Background (RMBG). The card says what it does rather than leaning on the heading above it, because one operation can be filed under several headings;
  • one line on what the model is good for;
  • what it takes and produces, as icons: a picture, a clip, a prompt, a sound;
  • Ready when this project has already picked this model for this operation;
  • Recommended when it is one we suggest;
  • popular when more people build with it than with most of the catalogue;
  • any licence restriction -- a model marked non-commercial is fine to experiment with and not for work you intend to sell;
  • the Runs-on line -- the part that is about your setup.

The Runs-on line answers "what does this cost me, here, now", and it never guesses. Local comes first, because it is the free answer:

It says It means
Local: ready The files are already on your machine. Nothing to install.
Local: fp8 build, 14 GB to install We looked, and the files are not there. It fits your card. Press the line and it takes you straight to the files this model needs, ready to download.
Local: not found when last checked Sep 12, 2026 Your ComfyUI is not running right now, so OA is quoting its last look at your machine rather than a fact about today. The line still takes you to the files this model needs; start ComfyUI and the line is checked again.
Local: not checked Nobody has looked at your machine yet -- OA has no hold on your ComfyUI folder, so it does not know what you have and will not pretend to. The model is still offered, and if a file really is missing ComfyUI will say so. reconnect the ComfyUI folder beside it takes you to where you can grant it again.
Local: runs, but slow on your 12 GB card It is bigger than your card, but it will work by spilling into system memory. Much slower, and free.
Local: too big for your card Not realistic on your machine. Use the cloud for this one.
Local: tell us your card in Settings We do not know what graphics card you have, so we cannot say. The line takes you to where you can enter it.

| Local: memory needed not recorded | We have no figure for how much video memory this model wants, so we cannot say whether it fits your card. | | Cloud: ready | Comfy Cloud can run this and your key is set up. A price is added -- "about $0.02 per run" -- once you have actually run it and we have a real figure to quote. Before that there is no number, because a made-up one would steer you wrong. | | Cloud only | This model is a paid service; there are no files to download and your graphics card is irrelevant. | | Local only | The model is on Comfy Cloud, but this workflow uses nodes Cloud does not have, so Cloud would refuse it. It runs on your own ComfyUI. If you have none connected, the run is declined before anything is sent, with a message naming the missing nodes -- Cloud is never asked to run it. |

While your local ComfyUI is running, the Local clause is checked live: OA asks ComfyUI itself which model files the selected operation's loaders can see, so a model you installed this morning reads Local: ready without rescanning anything. What it learns is saved, so the model list and the AI Models page agree with it, and a run that finishes on your ComfyUI records the files it used. Opening Files needed checks its files against ComfyUI again as well.

One order, and nothing is turned on

There is no setting to find before a model can be used, and there is nothing greyed out waiting to be switched on. Every model the catalogue has an operation for is listed, in ONE order:

  1. the ones this project has already used for this operation -- marked Ready
  2. the ones an experiment here decided in favour of
  3. Recommended
  4. popular
  5. everything else
  6. last: the ones that cannot run here right now

That last group is still shown, with the reason and the fix written on the card: Local: 3 files, 21 GB to install (which takes you to that model's files), or Cloud: switch Cloud on in Settings. Nothing is hidden from you, because knowing what exists is part of choosing.

Once you have chosen, the list gets short

An operation you have already settled shows what you settled on. Under its heading sits a small Show 1 more chip, and behind it are the other models for that operation -- the ones you have not chosen yet. Press it and they all appear; it then reads Show fewer. Nothing is thrown away and nothing is ranked differently -- the order above is exactly the order you get back.

A model you have not chosen is not chosen yet, which is not the same as bad. It is simply one you have not tried, and the chip is there so a list of thirty models does not stand between you and the one you already trust.

The list folds only where it can be helpful, so you will see it whole whenever that matters:

  • an operation you have decided nothing about shows every model, with no chip -- a new project looks like the full catalogue, because it is;
  • a search or filter folds the same way: what matched your decision shows, and the other matches are behind the chip. A search that only matches models you have not chosen shows them all;
  • inside an experiment nothing is folded at all. Trying the models you have not chosen is the whole reason you opened one.

The chip starts folded each time you open the list, the same way the search box starts empty.

Custom workflow at the end of an operation is for the graphs you have imported yourself.

See every model at the bottom of the list takes you to AI Models -- the catalogue of every model there is, what to read about each, and what is installed here -- with a back arrow to the gallery you came from.

Use here; Try in an experiment

In this gallery, pressing a model card is the whole of it -- Use. There is nothing else on the card, because a trial does not belong in the gallery you are trying to keep tidy.

  • If the card says Ready, it runs. The project has already settled how it runs this operation with this model, so there is nothing to ask.
  • If it does not, you are asked which build -- one short question. A build is described by what actually differs between builds: its precision or packaging, how much there is to download, how much video memory it wants, and where it runs for you. Most models have exactly one build today, and then there is no list at all -- it simply says One build is available: fp16, 6.9 GB. and you press Use. Where we have not recorded those details it says so rather than guessing. Confirm and it runs, and from then on that card says Ready.

You are not limited to one model per operation. A project can have RMBG ready for photographs and BiRefNet ready for line art, and both are simply ready.

When you do not know which model you want, start an experiment: select the pictures to work on and choose New experiment from selection. The build question offers Try in an experiment too, for exactly the case where the honest answer to "which build" is "show me". Inside an experiment the same model cards carry Try beside them, and Try the recommended set above the list -- each runs on the experiment's selected inputs, into the experiment, and nothing is decided. Try several models, try several operations, star the one that won and write the line you learnt; that is what makes it Ready for this project.

A trial always goes to Comfy Cloud when the model is there, even if you normally work locally, and to your own machine only when the build fits your card and its files are not known to be missing -- so trying a model never asks you to download one. Where it cannot run at all, Try is shown greyed with the reason on it. The button never shows a price.

One thing Try will not do: run with nothing selected, because a trial runs on your own artwork.

A look can recommend a model

When the shot is in a visual style that recommends a model for the operation, that model is preselected, and under the operation's name the Recipe panel reads Ready -- fp16, 6.9 GB -- Local: ready: whether this pair is settled, what the build is, and where it runs for you. It is a statement, not a control -- the heading above it is where you go to change anything -- and the card is marked Ready and comes first in the list.

With no style, or a style with nothing picked for the operation, nothing is preselected: every model for the operation is listed and you pick. To make a pick stick for a style, choose the recipe on the Visual styles page.

It is a memory, not a lock. Pick a different model whenever you like, and it applies to this project only, because the model that suits one show's artwork need not suit another's.

Deciding an experiment can set it too: star the trial that won, write the line you learnt, and the model you starred becomes a recommendation of the look you choose. That is the better route, because the choice is then one you have actually seen the evidence for.

Closing the panel when you just want to look

When nothing is being generated, that panel is a quarter of the width you could be spending on pictures. The > chevron in the panel's top corner slides it away and the gallery widens to fill the space; the view, sort and ... controls travel with the gallery's edge, so they stay where you expect. Dragging the divider hard to the right does the same thing.

Closed, a < chevron sits at the gallery's right edge -- press it and the panel slides back, the same width you left it. The panel remembers whether it is open and how wide, so it comes back the way you had it next time you open that gallery.

It only closes because you closed it. Anything that actually needs the panel brings it back on its own: Load as Operation, the Assistant setting up an operation, or a run starting.

The Recipe panel is what the Assistant is holding

The operation showing in the Recipe panel is not private to that panel -- it is the gallery's own current piece of work, and the Assistant works on the same thing. Ask it to remove the background from a picture and the Recipe panel switches to that operation with the picture already in its Source Image: you are watching it set the job up, and it runs the job itself rather than handing you a button to press.

That works both ways. Anything you fill in yourself is what the Assistant sees if you then ask it to run the operation, or to change one input and run it again.

A recipe is a list of steps

A gallery's recipe can hold several operations. Choosing an operation from a step's name swaps that step; asking the Assistant for something else adds another step. You can reorder or remove steps once the recipe is your own copy (see The Recipe panel).

Ask for something that takes two or three operations -- a still, then the background removed from it, then an upscale -- and the Assistant sets up each as a step, feeds each result into the next and runs them. You can watch the steps one at a time, and when it is finished the Graph view shows the whole run as arrows: the still, the cutout made from it, the upscale made from that.

What an operation actually is

Every operation is one unit of work with named inputs, and it is either a ComfyUI workflow (a graph that runs on Comfy Cloud or your own ComfyUI) or a built-in operation that runs inside OA -- joining clips, cropping, generating a prompt, synthesising a line of dialogue. Both appear in the same list and both fill in the same way; which it is only matters for where the work happens. See ComfyUI Integration.

When one operation feeds the next, its output becomes the next operation's input, which is how a still becomes a clip. That link is what the Graph view draws.

A text box can hold a text FILE

Every text box in an operation's form takes either words you type or a text item from the gallery -- a description a vision model wrote, a prompt you saved, notes you uploaded. Drag the item onto the box and the box shows the file: its name, and the start of what it says. When the operation runs it receives the file's TEXT, not a reference to it, so a long description does not have to be pasted anywhere.

The small x on the file takes you back to an empty box, and typing over it replaces the file.

This is how one operation's writing feeds the next one's reading. Ask the Assistant to describe a picture and then read properties out of that description, and it puts the description it just made into the reading operation's text box as a file -- the same thing you would do by dragging it.

A pale yellow text box from the Graph view is different: it is the words a run actually used, not a file, so dropping one on a text box pastes its words in, where you can edit them. This works on every text box, including the combined Prompt box. The boxes that record which model and visual style a prompt was written for ("Model: Qwen Image 2512") are facts about that run, not prompt text, so they cannot be dragged.

Write prompt

A prompt box has Write prompt on the right of its heading. It writes the prompt for you from what the page knows -- for a shot: its action, camera direction, cast, location and props; for a character, location or prop: that entity -- and writes it the way the selected operation's model likes to be prompted, in the visual style in effect (the one the panel shows, such as "Watercolour, from this shot"). The words land straight in the box for you to read and change. If the box already had text, Undo puts it back.

You do not have to press it: a run started with the prompt box empty writes the prompt the same way first, and the words it used appear in the box afterwards. Clear the box and run again to have a fresh one written.

You do not have to press it first. If you run an operation with the prompt box empty, the prompt is written for you at that moment, the same way, and stored on the step so you can read what was used. A prompt you typed is never replaced.

A talking shot speaks from its first frame. On a shot with a spoken line, animate it in two steps: Talking First Frame (an Image to Video workflow) takes the shot's storyboard as the first frame, which stays exactly as drawn, and the character speaks the line from the prompt; Voice Transform Shot then gives that clip the character's own voice, keeping the picture and the timing. For Talking First Frame, Write prompt puts the shot's own line into the prompt (not words you typed) and the clip is as long as the line. For Voice Transform Shot the voice sample is the character's, set on the Character Voice page -- and nothing else: a TTS voice alone is not a sample. A character with no sample stops the run before anything is sent, with one sentence: "Sally has no voice sample. Make one from the TTS voice, or upload one on the Character Voice page." When you press Run on the panel, the message comes with a Make a voice sample button that takes you to that character's Voice page. On that page Make a voice sample renders three short sentences (you can edit them first) through the character's TTS voice and stores the result as the sample; an upload replaces it. Nothing makes one without you pressing the button or saying yes to the Assistant's offer. The same page has a Voice description ("young woman, broad Australian accent, flat deadpan delivery"): Write prompt puts it in front of that character's line in every speaking workflow's prompt. Left empty, the TTS voice's region supplies a default ("Australian English"). The clip-driven Lipsync models (Wan S2V, InfiniteTalk, LTX Lip Dub) stay available when you would rather drive the mouth from the recorded line.

Two characters in one shot: Talking shot, two voices. When two characters speak in turn in a shot, the shot's recipe is Talking shot, two voices. The first step is the same Talking First Frame, but the prompt carries both lines -- each next to the figure who says it, in the order they speak -- and the clip is as long as the two lines together. The second step, Speaker Split, records where the second speaker starts in that clip (more on it below). The third step is Voice Transform Shot (two voices). From the cuts that Speaker Split recorded, it makes two tracks the length of the clip: one holding only the first speaker's lines and one holding only the second's, with silence everywhere else. Each track has its dialogue separated from the ambience, is given that speaker's voice sample, and the two are added back together, with the clip's own effects and music mixed in again, so the ambience is kept and every voice lands exactly when it was spoken. The two voice samples are filled in dialogue order, one per character, exactly as for one character (a character with no sample stops the run before anything is sent).

Any number of turns. The shot's script says who speaks and how many cuts there are. If the first character speaks, then the second, then the first, then the second, that is four lines and three cuts -- two people talking several times. Speaker Split looks for one pause per cut, in script order, and the shot's record holds one entry per line. Still exactly two voices: a third speaker in one shot is reported, not run.

Finding where each voice starts. The Speaker Split step is one step with two ways of doing it, and you switch between them with the step's operation picker like any other step. From the pauses is the default: the lengths of the lines say roughly where each change of voice falls, and the longest pause near that point is taken as the change. It is free, needs no model and works on Local and Cloud, but it can miss when there is no clear pause, or when ambience or music fills it. The saved notice says how many cuts it made and which are best guesses. By hand (the button reads Mark by hand) shows the clip's waveform with playback and one marker for every cut, each part of the waveform named for the person speaking it (for example "Andara", "George", "Andara"): play it, drag a marker -- or tap the waveform to listen from there -- to the moment the next voice begins, and accept. The markers cannot cross, and there is one for every cut the script has; you cannot add or remove them. It opens on the pauses' result, so a drag only adjusts it, and it works with a finger as well as a mouse. When the pauses were only a guess at some cut, the note under the clip names that cut and offers Mark by hand in one click. The result is kept on the shot, so whichever way found it, the third step uses the same cuts. The assistant tells you when a cut was a guess and names this way, but never switches to it on its own. The characters must take turns; overlapping speech is not separated, and the timing and the music are not re-timed. Whether the voice conversion keeps the exact length of a track with long silent gaps has not yet been measured on a long shot -- watch the first result against the clip. Talking shot, two voices is the ready-made choice for two speakers; the voice-sample alternative below remains available, with its picture risk.

An alternative: speak in the voice of a sample. References to Video (MiniMax H3 Singularity, Voice Sample) and its two voices sibling give each speaker's voice sample (their uploaded or made sample on the Character Voice page) to H3, which speaks the shot's lines in those voices in one clip -- the way to give two speakers in one shot their own voices. It needs a local ComfyUI, and it is offered when more than one speaker has rendered audio, or when you ask for it.

The picture check. The trade-off is the picture: this route uses the storyboard as a reference, not a first frame, so only about one render in three keeps it. So every render of a talking shot is checked against the shot's storyboard when it lands. A render is rejected when its first frame no longer matches the storyboard, when its last frame has drifted away from it, or when it is much darker than the storyboard. A rejected render stays in the gallery, tagged rejected-render, with the reason on its card ("Picture lost: brightness 0.36 of the storyboard"); it is never picked as the shot's rough clip. The run then re-renders itself on a new seed -- up to three renders for one request -- and tells you what happened ("2 of 3 renders rejected for picture; the third is the one shown."), with the seed each render used. Pressing Stop ends it after the render that is running. Check the full-size render yourself: a short or low-resolution render does not predict the full one.

Pacing in a talking shot. H3 speaks exactly the words written, at its own natural rate, with about half a second to a second and a quarter between sentences and between speakers. The prompt cannot buy a long pause, a slow delivery, a delayed start, an overlap or a cut-off. When timing matters, put the speakers in separate shots; within a shot, the clip length sets the room around the words.

A prompt that a prompt generator saved to the gallery opens full screen as a readable prompt, with the model and visual style it was written for and a Copy button.

Operations that have an editor

Some things cannot be typed. Where to crop a picture, how bright to make it, how to line four layers up -- you have to see it. Those operations show an Edit button next to Run.

Edit opens the operation's own picture-based editor, already set to whatever the form holds: open Edit on a crop and the rectangle is drawn on the image where the numbers say it is. Drag it, resize it, press Save, and the numbers in the form change to match. Run then performs the operation from exactly those values -- Edit settles the inputs, Run does the work. Nothing is generated while you are in the editor, so you can open it, look, and close it again.

This is why the Assistant and the editor work together rather than against each other. Ask for "the top half of this" and the Assistant fills the rectangle in for you; open Edit to check it, nudge it, and Save. Ask for something only you can judge -- "crop in around her face" -- and it fills in the image and tells you to press Edit and place the rectangle yourself.

A few operations are their editor: taking a photo with your camera, recording a performance. Those have no separate Run step -- pressing Run opens the camera or the recorder, and what you capture becomes the operation's output.

An operation that runs inside OA never shows the ComfyUI controls, because there is no ComfyUI job to send anywhere: no Local or Cloud choice, no Queue, no Copy. Just the form, Edit where there is something to see, and Run. The Assistant works the same way -- ask it to crop a picture or read a line and it simply runs it, because there is no "cloud or local?" to answer. That question belongs to ComfyUI workflows, and it only asks it about those.

If a required input is still empty, Run is greyed out and hovering it says which ones -- so a crop with no rectangle tells you that instead of running and failing.

The Seed row -- another render, or exactly this one

Under an operation's other inputs sits a Seed row. The box is yours: only you put a number in it. Leave it blank and every run draws a new seed, so each render is different -- and the box stays blank however many times you run; the seed a run drew is remembered on the result, never written into the box. Type a number and every run uses that seed exactly, so the same words and pictures give the same render, which is how you reproduce one. New seed beside the row fills it with a fresh number once, so getting a different render from the same prompt and pictures is one press.

The row is why a reloaded operation behaves the way it does. Load operation from a result brings everything that made it. If you had typed a seed for that result it comes back too, so Queue gives you that same result again -- in a second, because ComfyUI remembers it. The panel says so when you press Queue with nothing changed. A result made on a blank box loads with a blank box. Change the words, change a picture, or press New seed, and the next run is new.

Any workflow whose samplers are set to pick a new seed each time has the row; one whose author fixed the seed on purpose does not.

The output tray -- what this operation has already made

At the foot of an operation's form, directly below its run buttons, sits a row of small pictures: the results this operation has already produced from the inputs it is holding right now. It appears only once there is something in it, and a new result joins it -- at the front -- the moment a run finishes. Run the same operation three times and you have three candidates side by side, without scrolling the gallery to find them.

The tray is filtered, not a history. Change an input -- a different prompt, a different source picture -- and it shows only the results that came from what the form says now. That is what makes it a set of candidates rather than a pile: everything in it is an answer to the same question.

Point at one and its card lights up in the gallery, and the Graph view moves to it, so you can tell which of a dozen similar pictures you are looking at. Click it to select it in the gallery, where you can then act on it; double-click to open it full screen. An operation that makes more than one kind of thing at once -- a picture and a written description, say -- gives each kind its own row.

Working backwards from an image you already have

Generation is not the only direction. If you already have a picture of a character, location or prop -- concept art, a photo, something made elsewhere -- you can put it in that entity's gallery and have the visual properties read off the image instead of typing them in.

Drop the image into the gallery, open the Recipe panel (the Recipe panel), press Choose an operation and, under Prepare an input, pick Image to Text (the Gemini card). It asks a vision model to describe the picture against that entity's own list of visual properties, and saves the description as a text item in the gallery. Then run Extract Properties on that description (or choose Review as property proposals on the text item's menu): you get proposed values for each property, shown on the entity's Properties page, where you accept or reject them one at a time -- nothing is written without your say-so.

Any text item in the gallery -- a description you generated, or one you wrote yourself -- offers Review as property proposals on its right-click menu, which turns that text into proposed property values for the entity whose gallery it is in.

Do that again

Selecting Load as Operation on any gallery item rebuilds, in the Recipe panel, the operation that produced it -- the same operation, the same prompt and settings, and the same images fed in. Change what you want and run it again.

It restores one operation: the last thing that happened to this item, not everything that ever happened to it. If the item came out of a chain -- text to image, then upscale, then remove background -- loading the final result gives you the remove-background step with the upscaled image already in its input. To work further back, load the earlier item instead; the Graph view shows you which item that is.

To get the whole chain at once, choose Load what made this on the same menu. It loads every step that led to the item as the steps of the recipe -- text to image, upscale, remove background -- each fed by the one before, ready for Run all. See The Recipe panel.

An input that has since been deleted from the gallery comes back empty, so you can see what is missing and drop something else in.

Both actions are on an item's menu in the Grid, List and Graph views, and appear only for items OA made -- something you uploaded has no method to read back.

This is how you repeat a good result without having to remember how you got it: the item carries its own ancestry, so the gallery can read the method back off it.

Run again, and run exactly

Two more actions on the same menu repeat the run straight away, without a form in between.

Run again runs the same operation, the same model and the same build, with the same inputs and settings, and a new seed (a blank Seed box stays blank and draws a new one) -- so you get another take, not the same picture back. Only where it runs is decided afresh, for you: a build your card cannot hold goes to Comfy Cloud, and one whose files are installed runs locally. What it will never do is quietly swap in a different model file -- if nothing here can run it, it says so and names what to fix.

Run exactly replays the graph that was submitted last time, exactly as it was, with the same seed, on the place it ran. Use it when you want the old result back (or want to reproduce it) rather than another take, even if the operation has been changed since. If you cannot use the place it ran -- it ran on Comfy Cloud and you have Cloud switched off, or on a bigger graphics card than yours -- it tells you that instead of failing halfway through, and Run again is still there.

Both appear only for items OA generated, and Run exactly only where the graph it ran was saved.

360 photos and domes -- media you can look around in

Two kinds of item are not meant to be seen flat:

  • A 360 photo -- an item tagged spherical.
  • A dome -- a location's 3D background (its panorama texture, plus a depth map if it has one, shaped as a sphere, dome or plane). When you save a location's dome settings, the location's gallery gets a dome item for it, tagged dome. The card shows the flat panorama texture. Save the same texture again and the item is updated; choose a different texture and a new item is added. The gallery item is a copy for looking at and working from -- the location's 3D view keeps reading its own settings.

Open either one full screen and you are standing inside it. Drag (or swipe) to look around, pinch or scroll to zoom. You turn and zoom; you cannot move, so you cannot wander out of the picture. A dome shows its flat floor and its depth-shaped walls just as the location's 3D view does. A cylindrical panorama still opens as the flat picture.

3D Viewer -- save a view as an image

The 3D Viewer operation (offered for 360 photos and domes) opens the same view with an output size choice and a Capture view button. It saves what you are looking at as an ordinary image in the same gallery. Its provenance records the item you looked around in, the direction you aimed (yaw and pitch), the field of view and the size, so the image shows up in the graph like any other generated image. You can capture more than one view without closing it.

The 3D Viewer needs a screen to draw on, so it can only be run by you: an unattended run (for example one the Assistant starts) has nothing to capture. The Spherical Crop operation is unchanged and still works on 360 photos; use it when you want a flat re-projection of the photo itself, and the 3D Viewer when you want to aim a camera inside a dome.

Image editing

The gallery includes a built-in image editor with:

  • Rectangular, spherical, and cylindrical crop
  • 3D Viewer, for capturing a view from inside a 360 photo or dome
  • Perspective and 3D pose tools (OpenPose SVG)
  • Colour adjustment and layering
  • Sketch mode

Layering -- stacking pictures, and putting a character behind the desk

The Image Layering operation stacks as many pictures as you like into one image. The operation's form lists the pictures you have given it and always shows one more empty slot; take one out and the ones below move up. Edit opens the layering editor: the stack is a list of layers, the top of the list is the front of the picture, and you drag a layer by its grip to move it in front of or behind the others. Each layer is a card: open it to see everything you can change on that layer, and close it to keep the list short. Drag a layer on the picture to place it, drag a corner to resize from that corner (the opposite corner stays where it is, and the layer keeps its shape), drag an edge to crop it, or type the numbers. The panel on the right can be made wider by dragging the divider. Scroll the mouse wheel over the picture to zoom the view in or out around the pointer -- to fine-tune one area, or to reach the corners of a layer that is bigger than the frame -- drag the empty area to move the view (on a tablet, pinch with two fingers), and press Fit to come back. Zooming only changes what you see; it never changes the picture you save. Add a picture in the editor puts another picture from this gallery on top. The first picture in the form is the background at the bottom, and each picture after it goes above the one before; reorder the layers and your order is kept.

A character that turns. A spin video -- the video the References to Video (MiniMax H3, Spin with Mask) workflow makes, a character turning a full circle with its cut-out mask beside it -- can be a layer too. Add it like a picture, select its layer and use the Turn slider, or the previous and next frame buttons, to stop on the angle you want: facing left, front or right. The editor draws that frame cut out cleanly around the character, and the saved picture shows the same frame. The first time a video is opened the editor quietly prepares every frame in the background (a counter shows how far it has got); until then the slider still works, and once it is done -- and on every later visit, because the browser keeps them -- turning the character follows your finger smoothly. Because it is an ordinary layer, you can put it behind a mask shape.

A mask shape is a layer. A flat picture of a newsroom has no depth, so a character cannot stand behind its desk -- unless the desk is a layer in front of her. Select the newsroom layer and press Add mask shape, then tap points around the desk; tap the first point again to close the shape. The shape appears as its own layer directly above the picture (a shape you have not named goes on top of everything), drawing that picture's own pixels inside the outline -- so it looks like the desk and it moves and scales with the picture. Put the character's layer under the shape layer and she stands behind the desk; drag her above it and she stands in front. Drag any corner of a selected shape to reshape it, rename it, or delete it.

To change a shape, drag its points. Double-click (or double-tap) an edge of the shape to add a point there, then drag it -- for example, pull the bottom of a desk shape down over the floor in front of it so the character's legs are covered too.

Name your mask shapes. A shape with a name ("desk", "table") is a mask a character can be behind; the start frame for a shot puts a character behind it when the shot says so, and puts everyone in front of it otherwise. There is no "in front of": no "behind" means in front of every named mask. A shape with no name is a foreground item: it is drawn on top of every character. That is legal but not good practice, so give each shape a meaningful name. A shape still called "Shape 3" counts as unnamed.

Markers: name where a character stands. A marker is a named place on a picture, saved with it, that tells the start frame where a character should stand and how big they should be. Select the picture layer, press Add marker, name it ("left seat behind desk", "right seat behind desk"), drag the round dot to where the character's feet stand and the square handle to the top of their head (or use the Character height slider). A marker has a position and a size; a mask shape has neither, only its name and outline. Markers follow the same rules as mask shapes: a link shows the original's markers until it has its own set, Make a local copy copies them, and a crop carries them along. Each picture and its markers are independent, so reusing names across pictures is only a habit that makes the AI's job easier. The AI that plans a shot may pick a marker and a mask to stand behind for each character, from the names on the shot's camera angle; a name that is not on the picture is ignored. It is a first guess: dragging the layers in the start frame step still corrects it.

The shapes belong to the picture, not to the step. A mask shape is saved on the picture it was drawn on, so the next time you add that picture to any layering step its shapes come with it as layers above it -- you draw the desk once. A link to a picture shows the original's shapes until you change them; once you do, the link keeps its own set (the whole set, never a point here and there). Make a local copy copies the shapes the link was showing. A rectangular crop of a picture carries its shapes along, cut to the crop. A picture that was only made from another -- an upscale, a relit version -- does not, because it may no longer line up.

Everything is touch-friendly: there is no right-click or hover-only control, a double-click works as a double-tap, and the handles are larger on a tablet.

The size of the layered picture. The editor's Output Size starts at the episode's Rough clip size (the project's, outside an episode) the first time you open a step. A step you have already saved keeps the size you gave it.

Layering steps saved before layers became a list open as they were: their four pictures become the first layers, and the next Save stores them in the new form.

Tags

Items can be tagged for filtering and workflow targeting. Tags support suggestions and can carry purpose hints (first, last) used when ordering items within a generation sequence.

A picture, video or sound made by a step that draws in a named art style (for example Anime or Watercolour) carries that art style as a tag; a step that uses the model's default art style adds none.

A tag names a set. That is different from a star, which means "starred". An item can carry any number of tags, and a tag implies nothing about quality. Tagging also never hides anything -- the gallery is a scratchpad, and an untagged item stays exactly as visible as a tagged one.

Pose and camera angle names

Two kinds of name sit beside tags. An item's Edit Metadata has Pose and Camera angle fields in every gallery, beside the description and tags, saved with the one Save. Type a name or pick one of the names the gallery already uses (the list narrows as you type), and the X clears the box -- saving an empty name removes the name. The name belongs to the item and goes with it wherever it goes, so two items in one gallery can carry the same name -- try several "hands on hips" clips in a Shot, then keep the winner. A character or location look also remembers its preferred item for each name; that is the one a Shot and the Assistant use. An item with a name the look has no preferred item for becomes the preferred one by itself; if the look already has one, you are asked whether to keep the current one or use this one. When a name has more than one item in a look, the preferred one shows a green tick and the others offer Make preferred pose / Make preferred camera angle in their menu. Delete the preferred item and the newest remaining item with that name takes over. The names show on the card, the details row and the Info card, and the filter button beside the sort controls (Poses, Camera Angles; a tick means on) keeps only items that carry one. See Characters and Locations.

Tagging several items at once

You can name a set in one go. Select the items you want -- click one, then Ctrl-click (Cmd-click on a Mac) to add others, or Shift-click to take a run of them -- then open the gallery's More options menu and choose Add Tag. Type any word you like and it is applied to everything selected. Remove Tag works the same way in reverse, and takes away only the tag you name; the item's other tags, including the ones OA fills in automatically such as media type, dimensions, and duration, are left alone.

Tags match without regard to capitals, so an item never ends up with the same tag twice.

The turbo tag

OA's workflows ship at full quality, with no speed-up. If a run did use a turbo (step-distillation, "Lightning") LoRA -- a workflow you imported or edited that switches one on -- every file it saves gets the tag turbo, so you can spot and filter them. Those LoRAs make a run much faster, but they damage regions the model has to invent (stray glowing hands, see-through bodies), so keep them for a quick draft and never for a final render.

This is the fastest way to hand a chosen set to the assistant: generate ten images, look at them, tag the five good ones, and then talk about that tag by name.

Choosing which output the next operation uses

Running an operation several times gives you several candidates -- the operation's own output tray is where you compare them. To carry one of them forward, drag it into the next operation's input -- or tell the Assistant which one you mean, and it sets the next operation up with that item already in place.

Nothing is picked for you. The input holds the item you put in it until you put a different one there.

Feeding one shot from another

The same works across shots. An output produced in one shot can feed an input in a later shot -- not only the next one, but any later shot that refers to it. The Graph view draws those cross-shot connections explicitly.

Starred items from the earlier shot's gallery make your best candidates easy to find -- but you drag the one you want into the input, rather than having it wired for you.

Provenance

Every gallery item generated through a ComfyUI workflow carries provenance: the operation that produced it, the input files used, and the workflow JSON. This is what powers the Graph view and Load as Operation. Provenance is stored when OA detects a completed job and routes its output to the gallery.

It also records where the run happened and which build made it. Choose Info on an item's menu and its Media Information has a Run section whose Ran on line names the place -- Local or Comfy Cloud -- and the model file the run actually loaded. This is what lets a team answer two different questions about one picture: what was approved, and what actually ran. An item made before OA recorded this reads "Unknown"; it is never guessed at from the picture.

The Assistant reads the same line, so you can ask which build made a particular item instead of hunting for it.

The MCP Path row

Media Information also has an MCP Path row. It is the item's one address for outside AI tools that connect over MCP: paste it to a tool and it can read the item's details, get a short-lived download link for the file, and act on that item. The row is left out when the gallery the item belongs to is not known.

Made From

For a generated item, Media Information lists what it was made from: every picture, video or sound the run used, with a thumbnail, its name and its MCP path. Click the path or the thumbnail to open it full screen -- in this gallery, or in the character, location or prop gallery it lives in. An input that is no longer in any gallery is still listed, marked as such, because the run did use it. Prompts and settings are not listed here.

Where it appears

The same Media Gallery component is used on:

  • Projects -- the project-wide workbench, for trying a model or workflow when the result belongs to no single entity
  • Characters -- character visual references and generated images
  • Locations -- location reference imagery and generated backgrounds
  • Props -- prop visual references
  • Episodes -- media that belongs to the whole episode, such as a music bed
  • Scenes -- scene-level media
  • Shots -- shot-level generated media (the primary output of The Shoot)
  • Experiments -- the trial pictures of an experiment, on its Media page