Chatting

On the workflow view it is the column down the right of the canvas. Hit the button at the far right of the header to collapse it and the canvas fills the screen. Once collapsed, an AI Agent button floats in at the top right to call it back — it sits right where the column was, so it expands back in place, and on the desktop it is the only way back in. Collapsing only hides it — the half-typed message and the conversation so far are all still there.

On the chat view the canvas takes the right half: the conversation sits on the left, the canvas shows on the right, and the seam between the two can be grabbed and dragged — that is how it opens. To give the whole workspace to the conversation, hit Hide canvas at the top right and the canvas goes away; hit it again and it reads Split with canvas.

The storyboard view (1.5) uses this same Agent column, and switching views doesn't budge it — switch mid-conversation and the conversation is still there. It expands once on its own when you go into the storyboard (everything over there is worked on through the conversation, so you need the input bar in front of you to have a next step), and it collapses again just fine after that.

The header and the input area both float over the message stream: messages fade in as they scroll under the header and fade out before the bottom edge, rather than being sliced off mid-line.

Left of Collapse sits Full-screen chat: it spreads this column across the whole workspace — that is, it switches to the chat view — where this row moves up into the top of the screen (the title to the top left, the actions to the top right) and the last button becomes Exit fullscreen.

History is kept per canvas: the conversations you had on this canvas are here, and another canvas has its own set. Go back to one and the agent reads that conversation again — you and it are looking at the same history.

Four kinds of things show up on the timeline: what you said, what it said, what it did, and the nodes it produced. Once the jobs it handed to the background (image / video generation and the like) have all settled, the timeline also gains a gray receipt line on its own — which ones made it, which ones didn't, without you watching the canvas.

The order means something: it says what it is about to do, then does it, and gives you a summary at the end. So those gray lines in the middle read as a running log of the turn — what worked, what didn't, no guessing.

While the turn runs, a gauge row sits at the bottom of the message list: a spinning orb, a word on what it is doing right now (Thinking… while waiting for the model to speak, Replying… while words are streaming out), with elapsed time ticking by the second and credits climbing alongside; when it hands work to the background, a "N tasks running" chip joins the row — open it for a list of each job's node and stage, and click one to jump to that node on the canvas. If the request itself fails (network, upstream), the timeline gets a "The request failed" line with a Retry button — it runs the same message again as it was, and whatever the model had already said before it broke stays on screen; when there is a plain reason (most often not enough credits), that sentence is written right on the failure line.

When a turn has finished talking, the last line carries a row of small actions: Copy takes everything it said this turn (joined across tool lines and question cards); Dislike tells it the turn missed (a feedback dialog opens and sends the problem from that turn so it answers better next time); Retry only hangs on the last turn. Your own bubble has the same row underneath — Copy takes what you said, Retry sends that message again. A finished turn also keeps its account at the right end: "3 minutes ago · ⚡42" — click the number for this turn's usage breakdown.

Two more kinds of bubble turn up on the timeline that are not things you said; each has its own look, so neither gets taken for your typing:

• A platform note — its title reads "What the platform sent the agent". It is the platform speaking on your behalf (a pre-delivery self-check did not pass, or the Agent stopped halfway and the platform tells it to carry on), and it sits on its own; you do not need to answer it.
• "The N pictures the agent looked at" — the pictures it looked at this turn (previz frame sheets, comparison images and the like); open it and there they are. What it looked at is one more clue for judging whether the result is right.

When you switch conversations, the input bar, send button, stop button and “generating” state belong to the conversation you are viewing. If A is running a long job, switching to B to write a new request will not show B as typing or accidentally stop A. Return to A and its progress and output nodes are still there.

External assistants are just as visible. When Claude Code, Codex, Cursor or another assistant works through DOTV, its actions enter the same Agent timeline beside this canvas: which node it changed, what generation it submitted and whether the result finished are all clickable back on the canvas. You do not need to watch a terminal to know when it is done.

Halfway through a conversation and realize "it went off track from that one message"? Don't wrestle the same chat back — press Branch at the end of that turn: it copies the conversation up to the end of that turn into a new chat (the requirements discussed earlier and the finished results come along), then switches straight to it. The original conversation is untouched and stays in your history — switch back whenever you like.

The branched chat's title carries a numbered suffix ("… (branch 2)"), so you can tell at a glance in the history where it forked off.

• Enter sends, Shift + Enter starts a new line.
• Type @ to reference a node on the canvas. Besides nodes, the dropdown also lists Models (the image and video model lists) — @ one in and it uses that model for this turn instead of picking its own; at the end of the Nodes section there is also a Pick from canvas row (click a few in a row on the canvas and they all come in, see 10.5).
• Type / to choose a Skill (see 12.2).
• Local files brought in with the plus (or pasted straight in) line up as a strip of attachment cards above the text, and nothing sends until they are uploaded. Images land as a node on the canvas as well (and reach the agent like any reference); videos, audio and text files only travel with this message and build no node — in the bubble they are a chip you cannot click. Either way they take up your cloud space, and removing a card only takes it off this message.
• Cards in the storyboard can be dragged straight onto this card; drop one and it becomes a reference.

Select a node on the canvas and it turns into a reference in the input box — marquee-select five and you get five, deselect one and it drops off. So the right way to say "change this image" is: click the image on the canvas first, then say what to change.

A turn runs for minutes, so when something occurs to you there is no need to wait — press Enter while the previous turn is still running and that line goes in as a bubble inside this turn right away: the model sees it before its next move, without waiting for the turn to finish talking. That is the other road beside ⌘/Ctrl + Enter:

Anything waiting there can be dragged to reorder, taken back into the input box with the pen, or deleted with the cross. The queue is not stored on disk: refreshing drops it (those are things not yet said, not something already sent), and an empty queue is not shown at all.

When it isn't sure it doesn't guess: subject, style, number of shots, duration, aspect ratio — anything that changes where the whole film goes, especially when the next step is about to spend credits, it stops and asks.

While it's asking, the whole turn is suspended — it sits there until you answer. So Ignore doesn't close the card, it answers "your call" and lets it carry on. Some questions come with a countdown (better with an answer, fine without); letting it run out does the same thing as hitting Ignore.

When it has more than one question (three at most), the card shows one at a time: two to four options each, plus a field at the bottom to write your own.

• The bottom left says how far along you are (1 / 3).
• Leave the current one unanswered and Next stays disabled — a gap never waits until the last step to show up.
• Back returns to an earlier question any time; change it and carry on.
• Only the last question turns that button into Submit; pressing Enter in the free-text field acts as Next (and as Submit on the last one).

Five shots, a soundtrack, a composite — that easily runs for several minutes. The timeline itself is the progress: before each thing it does, it says in one line what that is, and the result of that step follows right after — so scanning the gray lines tells you where it has got to. There is no separate task list for you to watch.

While it runs, watch the gauge row at the bottom of the message list (elapsed time, credits, "N tasks running" all live there). Progress on any individual generation is drawn on the node (a breathing background and a percentage), not in the conversation — while a video renders, the canvas is the better place to look.