Canvas Mode: A Node-Based Workflow for AI Video Ads

Canvas mode is the node-based way to build an AI video ad. Instead of stepping through a linear wizard, you lay the whole production out on a canvas as nodes connected by wires: reference images, prompts, image generations, video generations, and the final edit. Each node does one job, takes typed inputs from the nodes before it, and hands its output to the nodes after it. The graph is the pipeline, visible all at once, and you can re-run any part without touching the rest. If you have used node editors in Blender, Houdini, or ComfyUI, the mental model transfers directly, and canvas mode applies it to the full ad production chain rather than a single image.

Canvas mode is a graph editor built into the SHOT.IS studio, where each node is one production step and each edge carries a typed artifact from one step to the next, whether an image, a video clip, or a piece of text. A minimal ad graph reads left to right: an import node holds your product photo, a prompt node describes the shot, a generate-image node produces the keyframe, a generate-video node animates it, and a composer node cuts the resulting clips into the finished vertical ad.

The ports are typed, so the canvas refuses connections that make no sense. You cannot wire a video into a slot expecting an image, and you cannot create a cycle. That sounds small, and it means a graph that connects is a graph that runs, while a colleague or a vision model reads the whole production plan at a glance instead of reconstructing it from a history of wizard screens.

Under every node sits its latest output: the generated still, a playable preview of the clip, the prompt text ready to copy. The canvas is simultaneously the plan, the control panel, and the review board.

A node graph beats a linear flow for one structural reason: AI video production runs iterative and branchy rather than linear. You regenerate shot three five times while shots one, two, and four sit approved, and you want two hook variants sharing the same body. A wizard models none of that, and a graph models all of it natively.

None of this changes what gets generated, since the shots still come from the same keyframe-to-video workflow we run everywhere. It changes the cost of iteration, because the graph makes “redo exactly this part” a first-class operation instead of a workaround.

Canvas mode ships with a small set of node types that cover the whole production chain from raw references to a rendered ad:

• Import: brings media onto the canvas, either uploaded from your computer or browsed from your library. Product photos, creator references, and music land here.
• Prompt: a plain text node for shot descriptions and look constants you reuse across branches.
• Video Prompter: an LLM node that takes your ordered reference images plus a one-line intent and writes the motion prompt, with timecoded beats and explicit references to each image. It turns “energetic product reveal” into a shot-ready prompt that cites @Image1 and @Image2 at the right moments.
• Generate image: produces the keyframe from prompts and reference images, using whichever image model you pick on the node.
• Generate video: animates a keyframe, or generates from text, with your chosen video model. Duration, aspect ratio, resolution, and quality knobs adapt to what that model supports.
• Composer: the endpoint. It takes an ordered list of video clips, optional music, and per-clip in/out trims, then renders the final ad at your chosen resolution and orientation in portrait, landscape, or square, up to 4K.

Every node caches its output together with a fingerprint of everything that produced it: its inputs, its parameters, its upstream results. When anything in that fingerprint changes, the node and everything downstream flags stale, with dashed connections showing which parts of the graph no longer reflect their inputs. Nothing regenerates until you say so, and when you do, only the stale part runs.

This matters because generation is the expensive step. In a six-shot ad where you tweak one shot’s prompt, a linear tool tempts you into regenerating far more than one shot, and video generations cost real money and real minutes each. On the canvas, five approved shots keep their cached results and the sixth re-runs. Swap the product photo that feeds all six and the graph tells you honestly that everything downstream is stale. Then “run stale” executes the affected region in the correct order, skipping any branch whose upstream failed and touching nothing already fresh.

The same logic runs upstream. Hit run on the final composer and the canvas executes any stale ancestors it depends on first, in dependency order. You never have to remember the right sequence, because the graph is the sequence.

Graphs execute on the server rather than in your browser tab. When you run a node or a whole stale region, the studio backend takes over: it routes each generation through the same provider, credit, and idempotency path as every other generation on the platform, supervises the jobs, and writes results back to the graph. Your browser becomes a viewport with live status, where running nodes pulse, finished nodes show their output, and the canvas refreshes while work is in flight.

You can queue a full ad covering keyframes, videos, and final composition, then close the laptop. Runs are durable too: if the service restarts mid-generation, stranded nodes get picked back up or failed honestly on startup instead of spinning forever. If you have babysat a browser tab through a 40-minute batch of video generations, this is the difference between a tool and a pipeline.

Each generation node carries its own model picker: image models on image nodes, video models on video nodes, LLMs on the prompter, music on the composer. The pickers group by provider, filter as you type, and show the credit cost of each option before you run anything. Pick a model and the node’s knobs adapt, because duration, aspect ratio, resolution, and quality options come from that model’s capability profile, so the canvas never offers a setting the model cannot honor.

This makes shot-level model routing practical. One model for everything is almost never the right answer in production. You want a premium model with strong physics for the hero shot and cheaper, faster models for B-roll and iteration, a strategy we break down in our comparison of AI video generators for ads. In a linear tool, mixing models per shot creates friction. On the canvas, it is whatever each node is set to.

Because nodes are addressable and outputs are reusable, variants stop being copies of the whole production. One approved keyframe feeds three generate-video nodes with three different motion prompts, compared side by side on one screen. Two hook variants share the entire body of the ad and diverge only at the first clip feeding the composer. The 80/20 of creative testing, meaning same body with a different hook as we cover in UGC hook patterns, maps onto the graph as a literal branch.

The composer node closes the loop: ordered clips in, finished ad out, with per-clip trims so you tighten each shot’s in and out points without leaving the canvas or re-rendering the clips. You get a rendered file at the aspect and resolution you asked for, whether a vertical 1080p cut for feeds or a landscape 4K master.

Canvas mode does not replace the disciplined process of reference-anchored keyframes, a QA gate before animation, short clips, and fresh anchoring per shot, all laid out in our AI ad production pipeline. It gives that process a spatial, re-runnable form, so the pipeline you held in your head or a spreadsheet becomes a picture that executes.

To try the shape of it, start smaller than a full ad: one import node with your best product photo, one prompt, one image generation, one video generation. Get a clip you would approve. Then branch a second motion prompt off the same keyframe and notice that the comparison cost you one node instead of one project. That is the habit canvas mode builds: iterate at the node level and pay only for what changed. If you would rather have the whole graph of references, models, QA, and the final cut built and run for you, that is what AI video ads at SHOT.IS are.