Node reference

One node, one task. The vocabulary stays small on purpose: nodes are meant to compose — a review gate is a Score, a Route and two Boards wired together, not a fat "Review" node with all three inside. This page is the whole set.

A shared rule first, because four nodes depend on it: stages mint, they don't mutate. A Copy, Imagery, Brand-fit or Edit node fed creatives that already exist (a Build's finished originals, a Source's seeds, a card you wired in) makes a new version of each and leaves the originals standing, so the two can be compared. Fed straight from another stage, it transforms in place instead — Copy → Imagery → Brand-fit is one act of production, not three generations of rows.

The heads

Brief

The campaign's direction: the message, plus optional goal, audience and tone, with an Improve brief button that rewrites your rough text in place for review. It sits on the wire between Templates and Build — the layouts pass through unchanged, and it attaches the direction the copy is written from. A second Build behind its own Brief is how one run says two different things. You only need a brief where something writes copy: a Source-headed run doesn't, and neither does a Templates node standing alone.

Templates

Finds the layouts, and stops there — it makes no creatives. It runs before the Brief and never reads one. Purpose leads the search: pick what the layouts are for (event, offer, hiring, …) and that alone is usually enough — it favours layouts whose own name, description or categories read like the job, without ruling any out. "What to look for" is optional freetext for whatever the dropdown can't say; describe the layout, not the campaign. Three more settings narrow the search: Search in (your shelf, the shared system library, or both — a system layout stays a candidate and only joins your brand when a Build uses it), Kind (branded or concept/parody), and Copy length (short/medium/long, read from each layout's own character budgets). Pin exact templates and matching plus every setting is skipped. A Templates node alone is a complete, runnable pipeline: "which of my layouts fit this?" is a real question.

Build

Makes the creatives. It deals its Originals round-robin across the templates that reach it (two templates, six originals: three each), then writes copy, places imagery and brand-fits every one. The run's creative count lives here and nowhere else. Config: copy model, image sources (Brand / Unsplash / AI as independent toggles — any combination, including AI-only; all off = no imagery; the AI toggle carries its own model picker — vendor and per-image price ride the options, omit for the platform default), Vary by axes, color-scheme fan-out, and Run instructions — per-run copy direction ("always mention the discount code", "write everything in Norwegian") layered on top of brand instructions and template playbooks, never replacing them.

Source

Seeds the run from creatives you already have, instead of a brief. Pick seeds from the library; the run works on copies, your originals stay untouched. This is the "make five variations of this" head: Source → Vary → Score → Board.

The transforms

Copy

The copy pass as its own node — rewrites each creative's text along the run's copy axes, with its own model and Run instructions. Takes an optional Versions count: at 2+, every arriving creative comes out as that many takes, and chained counts multiply (five images × three headlines = fifteen).

Imagery

The image pass — re-places each creative's photo from the configured source, with an optional Image direction in your own words ("Mariatorget at night, seen from above") that steers every pick. Same optional Versions count, varying the image.

It can give a text-only layout a background. If a creative has no image slots at all and the node's source allows generating, an Image direction makes the pass add one: it looks at the rendered creative first, writes a generation prompt composed around where your text sits (calm, readable regions behind the words), generates the image, places it behind everything, and hides the solid color it replaces — reversibly, in the layers panel. No direction, no surprise imagery: the add only happens when you asked for it.

Brand-fit

Re-fits each creative's layout deterministically — widow, overflow, cluster, POI. No AI, no credits, no count (N identical fits isn't a thing). By default it runs every rule the template enables — the same full pass as the editor's Brand-fit button. Or turn off Template defaults in its config and toggle exactly which rules run: just the widow-killer and overflow, just POI alignment after an image swap, whatever the batch needs.

Edit

AI manual editing from a plain-language instruction — "make sure the heading looks good visually, no widowed words", "keep the text off the subject's face". The node renders and measures each creative, then a vision model makes the small, targeted changes your instruction asks for — like directing the editor's assistant, per creative, at batch scale. One edited version per creative, always — the original stays for comparison, and chaining two Edits gives you both generations side by side. No count — an instruction has one answer per creative; wire a second Edit for a second take. It composes: wire a Brand-fit after it to settle the layout, a Score after that to judge the result.

What it can change: the words, position and size, whether an element shows on a format, text highlight treatment, CTA treatment, and the logo (its treatment or an explicit colour). It works within those, and says so when your instruction needs something outside them rather than making the nearest-looking change. Colour and font on text are deliberately not on the list: those come from the brand, so change them with a colour scheme or theme instead.

Translate

Language versions of finished work — the multi-market node. Wire it onto anything that's done (handmade seeds, a scored batch, a Route's winners) and it mints one translated version per creative, per language you pick — the original stays untouched. It translates the creative's existing copy, never the brief: meaning, emphasis and brand voice carry over, brand and product names stay as they are, and long languages (German runs ~30% longer) compress to fit each element's character budget instead of overflowing. Every version gets a brand-fit pass, because translated text changes length.

Pick languages from the grouped picker (all EU languages plus the other large ones — quick-picks for All EU and Nordics), and give any language its own instruction for this run. Standing rules — "never use em-dashes in Swedish" — belong on the brand instead: the Languages card in brand config holds per-language rules every Translate node inherits, with the app's baseline typographic conventions (quotation marks, formality defaults) underneath. The cascade is app → brand → node, most specific wins.

Each version is stamped with its language, so the rest of the graph can act on it: a Score judges translations like anything else, and a Route with a Language rule sends every market to its own board section — Translate → Score → Route (language) → Board is the whole multi-region delivery shape. One node, one thing: Translate mints and stamps; sorting stays the Route's job.

For each

One creative per subject — the batch node. You have one master creative carrying the campaign line, and a list of people or places it should be made for: point this at that list and it mints one version per subject, each with that subject's own photo and name, and the master stays.

Two ways to give it subjects, and the first needs no setup. Point it at a collection or tag of images and it reads one subject per photo, taking the name and title from each image's person details (the ones the Add people upload flow fills in). That is the candidate case end to end: drop 30 headshots in a collection, wire the node, done. Or point it at a Set — a named list of data rows — for subjects that aren't photos: municipalities, audience segments, product lines.

Names and titles are rendered from the data, never written by a model. In the template, bind a text element to row.label (the subject's name) or row.<field> (anything else in the list, like a district). A bound element resolves at render time and is excluded from every copy call, so a real person's name and title cannot be rewritten, reworded or invented. Mark the portrait slot useRowImage and each subject's photo lands in it — and because that slot is pinned, the imagery agent never substitutes a stock photo for someone's face.

Copy has two modes, and the default is free. Keep it as written makes no model call at all: the shared campaign line reads identically on every card, only the bound fields and the photo change, and a 30-candidate run costs nothing to write. Switch to Rewrite it for each subject only when the message genuinely differs — "Everyone in Stockholm should enter now" — and it buys one copy call per subject, adapting the message while keeping the angle, structure and tone identical across the set.

Sorting a per-subject batch is the Route node's job, not this one's. Route has a Subject field rule that reads what For each stamped — any column of your list, or the subject's own name — so For each → Route → Board sends every district, market or role to its own place. One node makes them; another sorts them.

It is not the Vary node, and the difference is the point: Vary makes N different takes on one thing and works to make them diverge; For each applies the same take to N different subjects, so its output is deliberately uniform apart from the subject. Two For each nodes chained is a legal cartesian product — every candidate in every region.

Vary

More versions of creatives that already exist. Point it at anything — the batch, one card, the winners off a Route — and it clones each input into as many fresh variants as you ask, on the axes you pick (headline, image, color scheme, tone…). The "give me five more like this" node. It never sets the run's count.

Rerun

A second attempt at the ones that didn't land. Wire it from a Route's weak path and every creative that reaches it comes out as one new creative, rebuilt with that creative's own critique as the direction; the original survives for a side-by-side. Nothing to configure — the judge already said what was wrong, which is why it needs a Score upstream. Its output is an ordinary batch: Rerun → Score → Route → Rerun is the iteration loop, every round visible on the canvas.

Judging and sorting

Score

Renders each creative and has a vision model rate it on its own merit — 0–100 overall plus any dimensions you add (emotional pull, conversion likelihood, brand consistency), each rated independently, no grading on a curve. Several Scores on one graph are fine — each judges its own wired subset, so one rubric per Build is just two Scores.

Route

Splits the set down named paths, first match wins: by overall score, by a dimension, by text content, by a yes/no vision question, or by template (sort the batch by which layout made each creative). Unscored creatives take no path until the judge has run — nothing falls to "else" prematurely.

The endings

Board

Dumb placement, on purpose: drops whatever reaches it onto a board (the run's own unless you pick one), optionally into a named section. A section can carry meaning — its confers setting marks arrivals approved, in review, or archived, independent of the section's color. It does not sort; wire a Route upstream and give each path its own Board node.

Delete

Permanently deletes what reaches it — the reject path's terminal, with no undo. Deliberately opt-in: it only runs unattended when "run automatically" is explicitly checked. Left unchecked, a launched pipeline reaches it and stops, the creatives sit untouched, and the run log records the skip — you run it yourself when you're sure.