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 half the vocabulary depends on it: stages mint, they don't mutate. A stage 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. Only the production trio — Copy, Imagery, Brand-fit — transforms in place when fed straight from another stage: Copy → Imagery → Brand-fit is one act of production, not three generations of rows. The refinement nodes (Edit, Translate, For each, Research, Make editable, Video) always mint — their whole point is a comparable version of finished work.

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.

Give each branch of a campaign its own Templates node and they spread: a node prefers layouts the run's other Templates nodes haven't already claimed, so three branches read as three treatments rather than one design three times. It only falls back to reusing a layout when your shelf is too thin to fill the branch. Leave Kind alone unless you specifically want one family — setting it to branded removes every concept layout from the search, which is the quickest way to make a whole campaign look the same.

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 (default GPT-6 Luna, thinking at high effort), 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; leave the whole setting untouched and the run follows the brand's own image-source policy from brand settings, which is how the AI toggle a brand enabled there actually reaches its runs), 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.

Images are seeds too. Add images… takes photos from the asset library — or files you drop straight onto the picker — and turns each into a creative the run starts from. That's the route from a picture to everything the factory does to a creative, and in particular it's how you animate a photo: Source → Video, with the Video node's attempts set to 3 or 4 so you get several takes to choose from in one go. Picking the same image twice reuses its creative rather than making another.

Ideas

Brainstorms ad concepts before anything is built, grounded in your Creative Context Library reference library. Each concept is generated in its own call with its own angle and an exclusive slice of the library's devices — so the set genuinely diverges — then a judge scores and ranks them. The concepts land in the node's config rail and as cards on the node's own lane, the way a Templates node shows its layouts: wire the lane's outlet to send the whole brainstorm onward, or draw a wire from one concept's card to address exactly that concept — into Templates ("search on this one") or AI Produce ("make this one"). Wire Ideas → Templates and the concepts steer the whole run. Three settings decide how:

• Write ideas for — Free ideas (the default) brainstorms from the brief alone; the best concept's layout description then joins the template search, so the layouts are found for the ideas. This pipeline's templates writes the ideas for the templates pinned on the Templates node it feeds: every concept call sees one template's copy roles, their character budgets and the start of its playbook, and designs the idea for what that layout does best — and only that template's creatives execute it. Pin the layouts first; until then the ideas are free.
• Ideas — how many to generate, up to 24 per brainstorm (one model call each, plus the judge). In template mode it's ideas per template, capped so the total stays within 24.
• What goes on to the build — The best N by the judge's ranking (default 3; per template in template mode), or All ideas. The Build deals its creatives across them, so a batch explores several ideas instead of rewording one; with All ideas, set the Build's Originals to at least the number of ideas so each gets a creative.

Each creative gets its concept's copy direction; the concept's imagined visual rides along as a soft hint the image picker only follows where a slot can carry it. Pin a concept in the rail and the whole batch executes that one. Standing alone it's a complete, runnable pipeline — pure brainstorming, concepts in the rail and nothing minted. Costs credits (one model call per concept, plus the judge); re-launching a run with the node unchanged reuses its session instead of paying again.

The node's Sources section decides which references it borrows from: filter the library by tag, starred, hook type, mood, or a search query (the query replaces the brief-derived search), with a live "N match" count — tick Use all matching references to offer the whole matching library instead of the top 25 by relevance (the brainstorm reads each reference's analyzed text, never the images, so a big library costs almost nothing) — or pick exact references from a large thumbnail picker, which beats everything. Your own ideas paste straight into the node: each is faithfully structured into a concept of its own (never re-invented), marked as yours, and ranked by the judge alongside the generated set — on top of the concept count. Knowledge — distilled material from the Creative Context Library's knowledge shelf — select docs onto the node and their thinking rides every concept call; when a selected knowledge carries named principles (Cialdini's, a formula's steps), those become the concept angles, one principle per concept ("Use principles as concept angles" turns this off).

AI Produce

Which of the three generation nodes? They all call the same AI image models, so what separates them is what comes out. Generate image makes a picture — a portrait, an office, a place — with no copy on it. Generate video makes a clip from words alone. AI Produce makes a finished ad: the whole artwork with the headline and call-to-action typeset into it, grounded in your brand. Video is the one that isn't a generator at all — it animates a creative you already have, using its render as the first frame.

Generates one finished ad per concept — no templates. The whole artwork comes from the image model, grounded in the brand two ways: a rendered brand board rides along as the reference image (the logo, the exact colors with their hex values, and the brand's letterforms — the full alphabet plus example headings in the real fonts — the same board the Video node references), and the brand's written guidelines ride in the prompt, with the concept's headline and call-to-action typeset verbatim. Feed it the whole brainstorm (Ideas → AI Produce, through a Hold if a human should approve first) or wire specific concept cards in — cards beat the batch. Pick which formats to generate; each (concept × format) is its own credit-metered generation. The output is ordinary creatives, so Score, Route, Board and Slack compose unchanged — AI Produce → Score → Route → Board judges the generated ads like any other batch. Idempotent per concept: re-running reuses finished ads instead of paying again.

Refine mode — creatives as input. Wire creatives into AI Produce instead of concepts — another AI Produce's output, specific cards, or any producer's lane — and each input is refined: its render rides along as the reference image of a fresh generation, steered by the node's instructions ("Refine the composition of these"). One new take is minted per input at the input's own formats; the original stays for comparison, so AI Produce → AI Produce chains into an iterative quality loop, every generation kept. A node takes one job: concepts or creatives, never both — use two nodes.

Tuning what the model is told, per brand: the brand-config AI generation section shows exactly what every generation for a brand receives — the brand board image and the written guidelines — and holds the brand's standing direction (aiImageInstructions): free-text rules like "never draw a box or outline around the logo" that ride EVERY AI Produce prompt for that brand. The node's own instructions field layers on top per run.

Generate image

The free image generator — no templates, no concepts, no inputs: takes come straight from your own prompt ("five colleagues around a standing desk in a bright office", "portrait of our CEO"). Set Takes (up to 10) and each is generated as its own creative, so you can judge them side by side and re-roll just the one that landed off. Each take decides what the takes are: Different situation (the default — "Hanna in a variety of situations" with 5 takes gives five single images in five situations, planned from your prompt at run time), Same scene (five attempts at the exact same prompt), or My own list (one line per take when you want to dictate the situations yourself). Don't list several scenes inside the prompt: the models read a listed series as a request for a contact sheet and answer with a 2×2 collage in every take. Reference images pins library images (a product shot, a location, a look your prompt refers to) that ride every take as references, so what they show stays recognizably the same while the prompt decides the scene — for a person, use People instead. Reference creatives does the same with a finished ad: point at one you already made and every take references how it looks. It is rendered fresh each run, so later edits to it carry over, and it shares the four-reference budget with the images. Pick the formats to generate (one metered generation per take per format), the image model, and the People to keep consistent — saved characters whose references ride every call. Brand context is opt-in, and off by default — a team photo usually shouldn't look like an ad: None sends only your prompt, Colors & direction folds the brand palette and standing AI direction into it, Full brand board also attaches the rendered brand board as a reference image. Every take lands as a flat creative and as an asset in the brand library, so Score, Route, Board and the Video node compose downstream — Generate image → Video is the image-to-video move. Standing alone it's a complete, runnable pipeline. Re-running reuses finished takes instead of paying again.

Generate video

The video twin — text-to-video from your prompt alone, no source creative and no first frame (to animate something that already exists, wire it into the Video node instead). Pick the model, resolution, clip length and aspect ratio (from the model's own list — with no first frame the ratio is sent explicitly), set Takes (with the same Each take modes as Generate image — a different situation per clip by default), pin Reference images exactly as on Generate image, and select People to keep recognizably consistent through the clip. Same opt-in Brand context as Generate image. Each take lands on its own flat creative carrying the clip, re-rollable individually; cost is the model's real per-second price per take.

Hold

A human review gate: the run pauses here — "Waiting for review" — and everything wired behind it waits until someone presses Continue on the canvas. Resuming re-launches the run; finished work is reused, nothing is re-bought. It never releases itself, and "run automatically" on downstream nodes still waits. Put it wherever a person should approve before the next step spends money or delivers: Score → Route → Hold → Slack, or Ideas → Hold → Templates to sign off on the concept before anything is built. The release belongs to that run alone — a fresh run from the same graph starts closed again.

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.

Pin images to say "use this exact picture." The rail's Pinned images picker takes library photos, and the pass then places exactly those instead of asking the image agent — no credits for the pick, and no guessing. One pin lands on every version; several are dealt across the versions in order (pin two and set Versions to 2 to get one of each). The image goes into the slot showing a picture of the same kind, so a person's portrait replaces the portrait and not the background, else the largest photo slot; icons and locked slots are never touched. This is the fix for "she wanted another picture": pin the new photo, run the node, and every creative gets a version with it. Agents pass assetIds on the node; an id written into the Image direction text is only a hint.

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 (Claude Opus 5.5 by default) 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, the logo (its treatment or an explicit colour), explicitly named colours ("make the orange heading black", a shape's fill), and image darkening. Image work is delegated, not refused: an instruction like "use Jakob's photo" is handed to the image engine — the one with the brand's photo library and person matching — as part of the same pass. It says so when your instruction needs something genuinely outside its reach rather than making the nearest-looking change. Wholesale recolors still belong to a colour scheme or theme; fonts come from the brand.

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.

Research

Live web research woven into finished work, with sources. Wire it onto anything that's done and it mints one researched version per creative — the original stays. Per creative it runs a real web search, steered by your instruction plus the creative's subject, its template's intent, and its current copy; then it weaves what it found into the copy. "Find a good verified quote from this candidate — a politician — and set it as the quote line, attributed – Name." "Find one recent local stat for this municipality and work it into the subheading."

Sources are enforced, not requested. A finding may only cite a URL the live search actually returned — one the model merely asserts is dropped before it can reach the copy. Quotes go one step further: the source page is fetched and checked, so a quote marked verified means those words are on that page. Quotes are used word for word or not at all — never paraphrased, trimmed or translated. Every version carries its full findings list with source links (creative.research), so a shipped quote stays traceable long after the run.

The pairing is For each. For each → Research gives every subject its own research: each minted version carries its subject row, and the research reads it — a verified quote per candidate, a local angle per municipality. The first quote it confirms also lands in the subject's data as row.quote (with row.quoteAttribution and row.quoteSource), so a quote template can bind the quote like any other row field — rendered from data, untouchable by any copy call. It composes anywhere creatives flow, though: research a timely angle for one seed creative, or for a Route's winners.

Each pass is a live web search plus a synthesis and a copy call, so it costs real credits per creative — put it after the batch is narrowed, not on ninety raw originals. A version whose research came up empty fails rather than shipping as a byte-identical clone pretending otherwise.

Make editable

Rebuilds a flat generated ad — an AI Produce creative, one full-bleed image whose pixels are the whole composition — into a real editable document. Wire it after AI Produce and it mints one editable sibling per flat input: the flat original stays for comparison, and inputs that are already element documents pass through untouched. Think of Illustrator's Image Trace, aimed at brand elements instead of vectors.

What "editable" means here is brand-connected. A vision pass reads the ad back into layers, then deterministic resolution rebuilds each one from the brand itself: the drawn logo becomes the brand's actual logo asset, sized and placed where it was drawn; each text block becomes a real element with its role set and the copy transcribed verbatim, so typography and color ride the cascade (a scheme flip recolors it like any hand-built creative); the CTA becomes a real button in the brand's own pill. Colors are measured from pixels, never guessed: an off-orange fill snaps to the brand's named orange as a var(--brand-*), a near-black heading resolves to no explicit color at all, and a color the brand doesn't have is kept as the unique value it is.

The background rides the imagery ladder. imagery: "match" (the default) looks for the pictured subject in the brand's own library first, then stock, then falls back to a clean-plate regeneration — the original artwork inpainted free of text, logo and UI, so the exact approved scene survives as a real background layer. imagery: "regenerate" jumps straight to the clean-plate, the most faithful mode. A picked photo is reframed by its focal point so the subject lands where the source ad had it.

Integrated artwork stays integrated. When a cutout, collage or silhouette effect is blended with the background as one composition, the rebuild never swaps in a lookalike photo: the background regenerates from the original artwork with the effect kept, and the exact drawn artwork rides on top as its own layer — present whatever the image model does with the plate.

Scrims and gradients are measured, never guessed as slabs. A dark readability band over the photo comes back as what it is: a plain fade uses the house sys-gradient-* styles, a held or unusually strong one gets a custom style minted to match the measurement (direction, peak opacity, how much stays at full strength), and a uniform semi-transparent panel gets its measured opacity. The foreground layers sitting on the panel are masked out of the measurement so white text can't read as texture. Inset images — a clipped graphic, a card photo — are cropped straight out of the source pixels (exact and free); when other layers overlap the crop, the region is regenerated with the overlays inpainted away first.

One vision call plus two deterministic calibration renders per creative (font sizes and positions settle against the measured ink per line, and a box the brand's wider face wraps is widened toward the margins), plus whatever the background rung costs.

In the editor, the background is your first choice. The Make editable button appears on any flat generated ad and asks one question before running: keep this ad's own image (the clean-plate — most faithful) or match a brand or stock photo (the ladder above). While it runs, the editor folds its chrome away and narrates the real stages like any other agent work, then lands on the finished rebuild in preview. Every rebuilt creative carries an Original toggle — in the topbar, and floating bottom-center in preview mode — flip the flat source over the canvas, compare, flip back and fix the details. Agents reach the same rebuild as one MCP call (make_editable).

Video

Animates a finished creative into a short clip. Wire it onto anything that's done and it mints one video version per attempt — the still original stays untouched, and the clip rides along on the new creative (a creative can hold a take for 1:1 and a separate one for 9:16). The rendered creative is the first frame, so the motion starts from artwork you already approved rather than from a text prompt.

To animate a photo rather than an ad, add the image to a Source node — it becomes a creative — and wire that in: Source → Video. Set attempts to 3 or 4 while you're there; video generation is non-deterministic and usually takes a few tries to land, and each attempt arrives as its own reviewable creative.

Direction is a sentence, not a storyboard. instructions is your motion note in plain words — "slow push in on the subject, let the headline settle last", "gentle parallax, nothing that pulls the eye off the price" — layered on top of the brand's own guidelines. Leave it out and a conservative default applies: tasteful on-brand motion that keeps every word legible.

Pick the model (Seedance 2.5, Veo 3.1 Fast, Kling 3.0 Standard — the node always stores which one it runs on, so a saved graph can't silently change vendor), the resolution, and the clip length in seconds, clamped to what that model actually accepts. Formats decides which aspect ratios get a take: each name is its own vendor round trip and its own charge, and leaving it empty makes a single take at the base format.

count is attempts, not axes. Video generation regularly needs a few tries before one lands, so a count of 3 runs three independent generations of the same creative and mints each as its own reviewable version — nothing is varied on purpose, the model's own non-determinism is the difference. Put a Board after it and pick the take that works; the clips loop there and in the editor.

Every take is a metered generation and the slowest thing in the factory, so it belongs at the end of a narrowed batch — after the judging, on the handful you'd actually publish.

Motion

Renders each finished creative's own motion — the clip the editor plays with K, planned from the brand's motion identity — to an H.264 mp4 per format. Nothing is invented: the copy stays the copy, the layout stays the layout, the brand's curves move it. It's deterministic and free (a screenshot per frame plus an encode, no AI model, no credits), which is what separates it from the Video node.

Wire it onto anything that's done and it mints one "· motion" version per creative — the still original stays untouched, and the clip rides on the new creative as a take (playable from the editor's format tab, looping on the board's card). What moves is the node's one real choice: Background only (the default — the photo drifts, the copy stays put: a still with life in it) or Everything (the copy enters in reading order, the button pops). Set the length (2–30 s; leave it blank for the document's own), pick formats (none = every format that moves) and the frame rate.

A layout with nothing to animate is skipped, and says so. A solid-panel canvas under Background only has no photo to drift, so the node names the creative and the reason in the run report instead of shipping a six-second still labelled motion — switch it to Everything, or pin a motion on an element in the editor.

Because it's free, it belongs wherever you want clips, but the documented shape is after the judging: Build → Score → Route(≥ 75) → Motion → Board animates the winners. Show it live on the canvas. A clip travels everywhere a still does from there: it plays on hover on the board and in the gallery, a Slack node posts the mp4 instead of the PNG, and a bulk download packs it beside the stills.

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 (Claude Opus 5.5 by default) 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.

Slack

Delivers finished work into Slack — the Board node's outward sibling. Every creative that reaches it is rendered (base-format PNG) and posted into a Slack channel, threaded under one message that carries the run's title and the board's review link. Pick a channel that's been bound to the brand in Brand settings → Slack; with no channel picked, a run that was ordered from Slack replies in the thread that ordered it. Delivery is idempotent per creative — re-running the node never re-posts what already landed. Like Board, it doesn't sort: Route upstream, one Slack node per destination. Creatives pass through, so a Board node after it still files the same work.

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.