Skip to main content
The creative canvas is a node-based generation pipeline editor. You lay out text, image, and video stages as nodes, use edges to declare which output feeds which input, then execute the whole chain in one pass.
The canvas is not a drawing tool. It doesn’t do flowcharts, architecture diagrams, or mind maps — for those, asking in chat for Mermaid or an image is a better fit. The canvas solves a different problem: a creative chain that takes several steps, several generations, and has dependencies between them — script → storyboard → an image per shot → each image to video.

​
Five node types

​
Edges define the data flow

An edge means “the upstream node’s output becomes the downstream node’s input”. Common shapes:

​
How to use it

1

Open the canvas

Canvas is a manually selected plugin. Enable it in the plugin panel and a canvas tab appears in the workspace.
2

Describe the chain you want

Say how many stages there are and what each produces. For example:
3

Check the structure before running

The expert lays out the nodes when it’s done building. Look at the wiring before you run — that’s the one moment when fixing a mistake is free; after a run, fixing it means paying for generation again.
4

Run one node first, then the graph

Run a single image node to confirm the style is right, then run the full DAG. Running everything with the wrong style means paying for a batch you’ll redo.
5

Iterate

Unhappy with one node? Re-run that node alone. Downstream nodes do not re-run automatically — you have to run them again explicitly.

​
The five operations available to the expert

concurrency defaults to 1, meaning sequential execution. An 8-node chain run sequentially takes the sum of all eight node times. You can ask the expert to raise it, at the cost of consuming more generation capacity simultaneously.
remix_from_node_id exists for variants: create a new node seeded from an existing video node, keeping its parameters and changing only the prompt — cheaper than rebuilding from scratch.

​
Billing

The canvas itself — creating nodes, wiring, layout, saving — costs nothing. Node execution is what bills:
Running the full graph costs the sum of every node, and there is no confirmation dialog. A “4 shots × (1 image + one 5-second clip)” chain is four image charges plus twenty seconds of video in a single run. Do the arithmetic first — a DAG run is not a free preview.

​
Where the state lives

The canvas runs as a separate frontend app embedded in the workspace panel through an iframe, talking to the chat over a message channel. Which means: canvas contents do not automatically enter the conversation context. For the expert to reason about the current state, it has to call canvas_get_nodes and read it first.

​
Failure modes and troubleshooting

​
Where this fits

Script → storyboard → stills → video, end to end. Changing the script only requires re-running the affected branch.
One text node fixes the style and world, fanning out to several image nodes. Consistency comes from the shared upstream rather than from re-pasting the prompt each time.
Wire several imageEdit nodes off one base image, each trying a direction, then compare side by side.
Canvases persist per user, so a structure that worked stays available — swap the prompts and re-run next time.

Image generation

Single and batch generation, parameters, and billing

Video generation

Duration-billed video capability

Plugin catalog

Every builtin plugin and its activation conditions

Billing formulas

Full algorithms for each billing unit