Workflow Copilot

Rolling out. The copilot is behind a switch while it ships; if you don’t see the panel yet, it isn’t enabled on your workspace.

Describe what you want; the workflow gets built on your canvas. The copilot reads your open workflow, adds and rewires nodes while you watch, proposes a run, and — after a run — reads what failed and fixes it.

There are two ways in.

From the home page — a box at the top of the page: describe what you want, press Build it, and you land in a new workflow with the copilot already building it. It can be dismissed and stays dismissed.

In both boxes Enter sends and Shift + Enter starts a new line, so a description can run to several lines and a pasted link can sit on its own. If a hand-off from the home page fails before the copilot answers — a lost connection, a closed tab — your sentence comes back into the box so you can send it again, and the empty workflow it had opened for you is cleared away on its own a few hours later.

From the editor — it lives as a side panel on the left of the canvas. Open it from the Copilot button in the editor toolbar, from the narrow tab beside the canvas, or with Ctrl/Cmd + J. Closing the panel does not stop a message that is still being written.

What it can do

Point at your own saved things

Type @ in the message box (or press the @ button) to pick from the characters, objects, animals and locations you have already made — and from your own images, videos and audio, under Files. The picker is organized in tabs, one per kind, each with its count; typing narrows the current tab, and a match on another tab shows up as a one-click hint so nothing you own is ever invisible. Characters, objects, animals and locations are all loaded, so typing filters them instantly. Files are searched across your whole library rather than only the ones on screen — the tab’s number is how many you have, not how many loaded — so a filename you remember will find its file however long ago you uploaded it. The expand button opens a full-size browser with large previews when you want to see what you are choosing. The name is written into your sentence, where you were typing it — because where you put it is part of what you meant: “@Emma walks in while @George raises the bottle” says who does what, which a list of names beside the box does not. The copilot looks each one up and can wire it into the workflow it builds.

A character row with saved looks carries a small arrow: open it to pick a specific angle, expression, pose or outfit instead of the default portrait. The pick lands in your sentence as plain words — @Iris (the "back" angle) — and the copilot turns that into the right configuration when it builds.

To use a file that is not in your library yet, press the paperclip and pick it from your computer. It uploads to your library and is attached to the message in one step, exactly as if you had mentioned it.

An attached image is one the copilot can actually see. Attach a screenshot, a sketch or a reference photo and ask for “something like this” — it reads the image itself: the layout of a template, the style of a shot, the text in a mock-up — and builds from what it sees. Up to four images per message. JPEG, PNG, GIF and WebP are the formats it can read; an attachment in another format (AVIF, HEIC) is still uploaded to your library and still named in your message, but the copilot answers from your words alone rather than failing the message.

Mentions travel as names and ids, never as file addresses — the same rule as What it will not do below. When the copilot uses one of your files it puts the id on the node and Nodaro fills in the address, so the rule that it can never type a URL holds even while it is wiring your own media.

A link you paste in chat is one it may place for you. Paste a YouTube link and ask for “a song similar to this”, and the copilot can put that exact link into the node built to hold one (a Reference Audio source, for example) — the node then fetches the audio on its own. This is the single exception to the no-URLs rule, and it only ever covers links you yourself pasted, copied character for character: the copilot still cannot invent a link, modify one, or write one anywhere else.

A character the copilot places this way arrives complete: the picture and the saved variants are read from your library when the workflow runs, so the run uses the right likeness even if the node was added a moment ago and you have not reloaded the page.

Before a run starts, the card lists every file that was attached to it, by name. Approving a run is the moment you agree to spend credits on that workflow, so anything the copilot wired in while building it is named there for you to check first.

Ask or Auto

Each conversation has a run mode, in the panel header:

Auto starts one run per message, and only when the price for the workflow on screen is already known — while it is being worked out, or if a run is already going, it asks instead.

In Auto mode a failed run is retried on its own: the copilot reads the failure, changes what caused it, and runs again. It does this twice and then stops and waits for you — a run that keeps failing cannot quietly spend your balance overnight. Press Fix it to give it another two attempts.

Either way the run itself is the normal workflow run: the same progress on the canvas, the same history, the same per-node credits.

What it can see

It only ever sees things that are yours: the public gallery is out of reach, and so is anyone else’s work. It does not browse the web.

What it will not do

Letting it build posting steps

By default the copilot cannot add a step that posts to TikTok, YouTube, Telegram, X, LinkedIn, Facebook or Instagram. Turn on “Let it build posting steps” in the panel and it can — for that conversation only, and off again whenever you like.

What it can do with that on: add a posting step and wire it into the workflow it just built, so a flow that makes a video can end by publishing it.

What it still cannot do, with it on or off:

The reason for the split: a posting step publishes to an account you already connected, so the worst case is something on your own timeline that you did not want, which you can delete. A webhook sends your media to an address written in the node, which is a different kind of thing entirely.

Choosing the default account

If you have connected more than one account on the same platform, Integrations lets you mark which one is the default. That is the account a posting step uses when it does not name one — which is every step the copilot builds.

With one account there is nothing to choose and no control is shown. If you have several and have not marked one, the oldest is used.

What it remembers

Tell the copilot a lasting preference — “always 9:16”, “never add background music” — and it saves it, once, for every future conversation. Memory is deliberately narrow and fully visible:

Choosing a model

Each conversation runs on one of three models, switchable in the panel header:

The choice is per conversation, and the “up to” price under the message box follows it. Switching models mid-conversation is fine — the next message simply runs on the new one.

Credits

A copilot message is billed for the assistant’s actual model usage. The panel shows an upper bound before you send; the amount actually charged appears under the reply and is usually well below it. A conversation that reaches the ceiling stops and tells you, rather than continuing silently.

Runs the copilot proposes are charged the same way any run is — per node, when you start them.

Studio surface

The same assistant also runs inside the studio editor, where the subject is a production — its shots, takes, cast, planned frames, cuts and soundtrack — rather than a canvas of nodes. It is one assistant with two surfaces, not two assistants: the same conversation loop, the same per-message budget, the same standing preferences, the same Stop, the same billing. What differs is a small bundle resolved for each message — which tools it may see, what it is told about its subject, and what happens when it calls one.

It writes nothing and spends nothing on its own. On the canvas the copilot edits the workflow as you watch. In the studio it does not: every change to the production, every generation, every export, share, import or copy comes back as a card, and the message ends there. You press Apply, and your editor makes the change through the same path a button in the editor uses — so your own unsaved edits are never overwritten and never lost. One card per message: if it wanted to do two things, it proposes the first and tells you the second.

Because of that, a change is previewed before it is offered. The card shows one line per operation, what class it is, and whether a delete can be taken back — read off the preview itself, never asserted in prose.

Other differences worth knowing:

Good to know