Workflow builder

Every run lives on a node canvas at Factory → Workflows. The same canvas is where you author a pipeline before anything runs, watch it build in real time, and come back afterwards to develop what it made. Nothing here is a diagram of the run — the canvas is the run.

Promises: the canvas shows the future

Before a pipeline runs, every creative it will produce already appears as a faint dashed placeholder — a promise. That's what lets you finish the whole pipeline (score it, route the winners, deliver to a board) before a single creative exists.

Promises come in two kinds, and the difference is whether braaand can tell them apart yet:

• Nameable ahead of the run — creatives built on templates you pinned, seeds you picked, and versions of either (a Vary's clones, a stage's versions, a Rerun's rebuilds, an Edit's edited takes). These are real, individual placeholders: you can drag a wire from one and give that single future creative its own path. The wire survives saving, reloading, and the run itself — it lands on exactly the creative that fills that slot.
• Decided during the run — which creatives clear a score, which way a Route sends them, which template auto-matching picks. Those stay one "some of these" placeholder marked ~? until the run decides. An empty lane would read as "everything was rejected" when nothing has been judged yet, so the canvas refuses to guess. Wire the lane's edge instead — it means "whatever comes out of here" — and the whole batch flows.

Change your pins or lower a Build's count and any wire to a promise that can no longer exist is cleaned up; if one slips through, the run refuses with a clear message rather than quietly sending the whole batch down that path.

Wiring

• Every lane has an outlet on its right edge — "everything this node produces". A Templates node's layouts have one just like a Build's creatives.
• A single card wired out leaves its batch. Wire one of four originals into its own Copy and everything downstream of the batch sees three — the canvas counts and the run agree because they're computed the same way. A diverted card shows a ring and a small ↗ chip until its path merges back.
• Wires are type-checked as you draw. Templates hands out layouts, not creatives, so Templates → Score is refused on the spot instead of launching a run that scores nothing.
• To disconnect, hover a wire — a × appears at its midpoint. (Backspace never deletes anything on this canvas; removal is always explicit.)
• Nodes never wire themselves. A node added from the toolbar lands placed but unwired — validation lists what's still unconnected and Run stays gated until the graph is runnable.

The wires themselves speak a small, fixed language: solid means it exists, dashed means it's still a promise; motion means work is in flight right now; thick wires are yours, hairlines are trails the canvas drew; the accent color marks a diverted card; faded means superseded history. Hover the node bar for the key.

Running

• Run pipeline launches the whole graph durably. Nodes marked "run automatically when the upstream finishes" chain on their own; the rest wait for you. One deliberate exception: a Delete node only ever runs unattended if you explicitly checked its box — an unchecked Delete is reached and skipped, and the run log says so.
• Every node also has its own Run. A Score judges what reaches it; a stage node makes versions of what reaches it. The default scope is exactly the creatives the wiring delivers — the same set the node's face counts and its ghosts promise. Select cards first, or wire specific creatives in, and the Run narrows to those.
• While a run works, a progress strip narrates it — phase, N/M ready, building, queued, scored, elapsed — and each mid-build card names its live stage with a ticking clock: writing copy, finding an image, fitting layout, applying edits.

Asking for it instead of wiring it

The command bar works on the canvas, and there it knows exactly which pipeline you're looking at. Summon it (⇧Space, or the orb in the corner) and describe the change:

"add a score node after the build and send anything under 70 to a Needs-work board"

The nodes appear wired and draw themselves in, the same way a canvas draws itself when you open a recipe. Then keep going in the same breath — "make it 20 originals", "drop the delete node", "what does this pipeline actually do?" It reads the live graph before every answer, so it describes what's on screen rather than what it built earlier.

Three things worth knowing:

• It edits, it doesn't replace. Anything you didn't mention is left exactly as it was — including your node positions. Asking to change one number changes one number.
• It won't wire by accident. Adding a node and connecting it are separate acts here, the same as on the toolbar, so nothing gets silently attached to the wrong Build.
• It won't run anything unless you ask. Building the graph is free; running spends credits. Ask it to run a node and it will.

A blank canvas is the same conversation from the other end: open Blank canvas and say "a campaign about saving the lions". It asks the one or two questions that genuinely change the shape, then builds the pipeline in front of you.

If a run is executing, graph edits are declined until it finishes — the running pipeline is reading that graph.

Different treatments per template

Want a really funny take on the meme template and a serious, polished one on the hero template, in the same run? That's two Build nodes. Pin both templates on the Templates node, then drag from a pinned template's card into its own Build: that Build uses that template and only that one. Each Build gets its own count, its own run instructions ("meme voice, no corporate tone"), its own copy model and image source, its own Brief if the branches should say different things — and can carry its own Score with its own criteria, so each treatment is judged on what matters for it. A Build with no template wired into it uses every layout Templates found, which is the ordinary single-Build shape.

Add a Route rule "by template" and the board arrives sectioned by treatment.

Saving what you built

Once a pipeline works, save it as a recipe — a reusable graph with slots you fill at run time. Saving from the canvas automatically makes the brief a fill-in slot (and the count an optional one), so a saved pipeline re-runs with a fresh brief out of the box. See Recipes.

The run log

Every run keeps a full account of itself: which templates were picked and why, each creative's stages with models, tokens and durations, the judge's scores and critiques, what was routed where, what a skipped or destructive node did, and the credit total. Copy run log in the right sidebar hands you the whole thing as text — built to be pasted to a colleague or an AI when you're debugging a run or hunting for waste.