Examples

Every pipeline below is a shape you can build on the canvas in a minute or two (Workflow Engine → New workflow), or describe to the command palette and have it drafted for you: "set up a pipeline that…" creates the graph as a free draft you review before running. The node reference explains each block; this page shows how they combine.

Four of them open on a real canvas. Where you see Show it live below, the shape gets drawn onto your own node canvas exactly as the app would build it, ready to run once you've filled in the parts only you can supply — your brief, your templates, your creatives. Nothing runs and nothing is spent until you press Run pipeline.

The reviewed campaign

The default shape — what a plain brief runs if you never open the canvas:

Templates → Brief → Build → Score → Route(overall ≥ 75) ─→ Board "Approved"
                                                        └→ Board "Needs review"

Templates finds the layouts, the Brief says what the campaign is, Build deals the originals and produces them, Score judges each on its own merit, and the Route pre-sorts the board. Change the threshold on the Route rule, add score dimensions ("Emotional pull", "Conversion likelihood"), or point the two Board nodes at different sections — it's all config on the wired nodes.

A quick batch, no judge

Templates → Brief → Build → Board

When you'd rather judge ten creatives yourself than read ten critiques. This is what the Batch recipe runs.

Variations of one creative

Source → Vary(×5, headline + image) → Score → Route(≥ 75) ─→ Board "Approved"
                                                          └→ Board "Needs review"

No brief, no templates — the seed creative is the input. Pick it in the Source node's library picker; the run works on copies, your original stays untouched.

Finished ads straight from the image model

Ideas → Hold → AI Produce → Make editable → Score → Board

No templates anywhere. Ideas brainstorms concepts from your Creative Context Library, the Hold pauses the run so a person picks over the concepts before anything is spent, and AI Produce generates one finished ad per approved concept — grounded in the brand board and your written guidelines. Make editable then rebuilds each generated ad into a real document (the brand's actual logo, editable text in the brand's own faces, a real button, a resolved background), so the judged winners can be fine-tuned by hand like any other creative. Wire a single concept's card into AI Produce instead of the lane to produce exactly that one.

And when it's quality you're chasing, chain the generator on itself:

Ideas → AI Produce → AI Produce ("sharpen the composition, calmer background") → Score → Board

An AI Produce fed creatives instead of concepts refines each one: the input's render steers a fresh generation, one new take per input, originals kept — so two or three in a row is an iteration loop where every generation stays on the canvas, comparable and judged.

Two treatments, one run

             ┌─ tpl A ─→ Build "Funny"  (4 originals, "meme voice") ──→ Score (Humor) ────→ Board § "Funny"
Templates ───┤
             └─ tpl B ─→ Build "Serious" (2 originals, "no jokes")  ──→ Score (Credibility) → Board § "Serious"

Pin both templates on the Templates node, then drag each pinned template card into its own Build. Each branch gets its own count, run instructions, judge and section, so it's one run in two voices. Give each Build its own Brief if the branches should say entirely different things.

Show it live on the canvas

The polish pass

You have a finished batch and want it tightened, not rebuilt:

(finished batch) → Edit("no widowed words, keep text off faces") → Brand-fit → Score

Wire the Edit node onto the batch's lane. Because the creatives already exist, every node here mints versions: the edited-and-refitted takes appear beside your originals, scored, ready to compare. Set the Brand-fit to Pick rules… if you only want specific rules (say, widow + overflow) instead of the template's full set.

Show it live on the canvas

Try a different copy model

The same mint-versions trick, aimed at copy quality:

(finished batch) → Copy (model: gpt-6-sol) → Score

Your originals already carry the run's default copy model's writing. Drop a Copy node onto the finished batch, pick a bigger model in its config, and press its Run — one new version per creative appears beside the original: same image, same layout, new words. Compare them side by side on the canvas, or wire a Score after the versions for the judge's opinion. You pay only for the copy calls, never for a rebuilt campaign.

To set the model before a run instead: press Hold off on the launch card (or ask the palette to set the campaign up "as a draft"), open the canvas, and pick the copy model on the Build node's config — nothing runs and nothing is spent until you press Run pipeline. The model list is the same trio everywhere: a cheap fast tier, the default workhorse, and the flagship, each available on two providers.

Before reaching for a bigger model, try Run instructions on the Build first — "headlines max four words, verb-led CTAs, reuse the campaign pun" often lifts copy further than a model swap, and it's free.

The iteration loop

Rounds are wiring, not a setting:

Build → Score → Route(≥ 75) ─→ Board "Approved"
                            └→ Rerun → Score → Route(≥ 75) ─→ Board "Approved"
                                                            └→ Board "Second look"

The weak path feeds a Rerun, which rebuilds each creative using its own critique as direction; a fresh Score and Route judge the second attempt. One wire is easy to miss: with two Scores on the canvas, the Rerun must name its judge — wire it from the first Score's small report port as well as from the Route's else path, so the rebuild is steered by the critique of the judge that scored the originals. The canvas flags it in red if you forget, and the Rerun's config has a "Reads score from" picker that draws the wire for you.

Want a third round? Wire another Rerun off the second Route (and its report wire from the second Score). Every round is visible on the canvas, and every original survives for comparison.

Show it live on the canvas

Route the losers to Delete — carefully

Score → Route(≥ 60) ─→ Board "Keep"
                    └→ Delete

Legal, and genuinely destructive: everything under 60 is permanently removed. This is why Delete is opt-in — leave its "run automatically" unchecked and a launched run stops at the node, letting you eyeball what reached it before you run it yourself. Prefer a Board "Discards" section over a Delete unless you're sure.

Animate the winners

Templates → Brief → Build(6) → Score → Route(≥ 75) ─→ Motion(background, 6 s) → Board "Clips"
                                                    └→ Board "Needs review"

The motion shape. The batch is built and judged as usual; only what clears the bar goes on to Motion, which renders each winner's own clip — the brand's curves, the background drifting, the copy in place — as an mp4 per format and drops the versions on the board beside the stills. Motion is free, so the judging in front of it isn't about cost: it keeps clips of rejected creatives off the board. Flip the node to Everything for the full choreography.

Show it live on the canvas

Which of my layouts fit this?

Templates("a hero layout for a LinkedIn new-hire post")

A single Templates node is a complete, runnable pipeline. It resolves its picks, mints nothing, and the run finishes: an answer, not a batch. Set Search in to both to include the shared system library when your own shelf is thin.

Show it live on the canvas

One creative takes its own path

Any batch, any of the shapes above — then drag from a single promise card into its own node:

Build (6 originals) ──→ Score → …            (5 continue here)
        └─ original #3 → Copy("only this one in French") → Board

The wired creative genuinely leaves the batch — the main Score sees five — and it works before anything is built, as long as the creative is nameable ahead of the run (pinned templates, picked seeds, and versions of either).