Edge Modes

How the lines between your nodes decide what flows through — and how much.

What’s an Edge?

When you drag a connection from one node to another, you’re drawing an edge. Think of it as a little delivery route: whatever the first node produces, the edge carries to the next node.

Most of the time, nodes produce one thing — one image, one video clip, one block of text. In that case, the edge just passes it along and you never have to think about it.

But some nodes produce many things at once:

A Split Text node can break an LLM’s answer into 10 paragraphs
A List or Loop node can produce dozens of items
Running a Generate Image node 5 times in a row leaves 5 images sitting on that node

When there’s more than one result to move, you need to decide: which one? all of them together? one at a time?

That’s what Edge Modes are for.

The Four Modes at a Glance

Mode	What it does	When you want it
Selected	The selected result (whichever one you picked with the carousel arrows)	Most of the time — it’s the default
Item	Picks one specific result by position	“Just give me the 2nd one” or “the last one”
Each	One by one — runs the next node once per item	“Do this for every item in the list”
Bundle	All at once — passes the whole list in one go	Downstream needs everything together (e.g., combine videos)

How to Change the Mode

Click the edge (the line between two nodes) on the canvas
A small dropdown menu appears
Pick one of: Selected · Item · Each · Bundle
The pill label on the edge updates to show what you chose

If you don’t see anything special on the edge, it’s in Selected mode — the default.

Mode 1: Selected

The default. Pass the result you’ve currently selected.

┌─────────────┐                    ┌─────────────┐
│  Gen Image  │                    │  Img → Vid  │
│             │ ───── Selected ──► │             │
│ 3 results   │                    │  runs once  │
│ ◀ ● ▶       │                    │             │
└─────────────┘                    └─────────────┘
       │
       │  Result 1: image A
       │  Result 2: image B  ◄── you clicked this one, so this passes
       │  Result 3: image C

What happens: The edge passes whichever result is currently active on the source node — the one shown in the carousel. After each run the newest result is auto-selected, so by default this means “the most recent.” But if you arrow back to an earlier result, that one flows through instead.

Use it for: Almost everything. Simple linear workflows where each node has one job and hands off one thing — including the “generate 4 variations, pick my favorite, keep going” pattern without needing any special mode.

Note: The word last also appears inside range and list expressions like 1..last or last-1. There, it means the final index in the array, not the selected result. Same word, different meaning.

Mode 2: Each (Fan-out)

Run the downstream node once per item in the list.

┌─────────────┐                  ┌─────────────┐
│ Split Text  │                  │  Image Gen  │
│             │ ────── Each ───► │             │
│  3 items    │                  │  runs 3x!   │
└─────────────┘                  └─────────────┘
       │
       │  "a cat on a beach"   ──► generates cat image
       │  "a dog in the park"  ──► generates dog image
       │  "a bird in flight"   ──► generates bird image

What happens: The edge “fans out” — the downstream node executes one time for every item. You end up with one output per item.

Use it for:

Split text from an LLM before processing — LLM gives you 5 scene descriptions, then you want to generate an image for each one
Batch generation — turn a list of 10 prompts into 10 images, or a list of articles into 10 videos
Loop tables — use a Loop node to define 5 variations (subject × style) and generate one result per row

Tip: The credit estimate on the downstream node multiplies by the fan-out count. If Each produces 5 items and the node costs 4 credits, expect ~20 credits.

Mode 3: Bundle (All at once)

Pass the whole list through in one go.

┌─────────────┐                   ┌─────────────────┐
│ Generate    │                   │ Combine Videos  │
│ Images      │ ────── Bundle ──► │                 │
│ (3 images)  │                   │  runs once,     │
└─────────────┘                   │  gets all 3     │
       │                          └─────────────────┘
       │
       │  [img1, img2, img3]  ──► delivered all at once

What happens: The downstream node runs once, but it receives the full list as its input. The node itself then decides how to use the whole bundle.

Use it for:

Combine Videos — stitch all upstream clips into one final video
Mix Audio — layer multiple audio tracks into a single mix
After Effects / Motion Graphics — feed a set of clips into a composite scene
Any node whose input is “a list of things to process together”

Rule of thumb: If the next node’s icon suggests merging or composing, use Bundle. If it suggests transforming one thing, use Each.

Mode 4: Item (Cherry-pick)

Pick one specific result from a multi-output node.

┌─────────────┐                     ┌─────────────┐
│ Generate    │                     │ Image to    │
│ Images      │ ─── Item: 2 ──────► │ Video       │
│ (3 images)  │                     │             │
└─────────────┘                     └─────────────┘
       │
       │  img1
       │  img2  ◄── picked
       │  img3

What happens: You type an index (like 1, 3, or last) and the edge pulls just that one item through.

Use it for:

Cherry-pick a favorite — generate 4 images, pick the one you like, send it to video
Reliable picks — always grab the last result or the first result from a batch
Combining with other nodes — use multiple Item edges from the same source to wire up different downstream paths

Selecting a Range or List (Each / Bundle)

When the edge is in Each or Bundle mode, the dropdown menu adds a Range tab and a List tab. These let you narrow down which items actually pass through.

Range Tab

Three fields: From, To, Step.

From: 2, To: last → skip the first item
From: 1, To: 5 → only the first 5 items
From: 1, To: last, Step: 2 → every other item (1, 3, 5, …)

List Tab

A single text box that accepts a friendly expression:

You type	You get
`1`	Item 1 only
`1, 2, last`	Items 1, 2, and the last one
`1..5`	Items 1 through 5
`1..last`	All items
`1..last-1`	All except the last
`1..10:2`	Items 1, 3, 5, 7, 9
`last..1:-1`	All items in reverse order
`1, 3..5, last`	Item 1, items 3–5, and the last one

Friendly syntax: Use .. for ranges, , to combine multiple picks, and last / last-1 / last-2 to count from the end. If you type something invalid, the box turns red but your workflow won’t crash — it’ll just treat the edge as “all items.”

Include Previous Runs

Normally, an edge only looks at the latest batch of results from the upstream node. But what if you ran a node 5 times manually over an afternoon, and now you want to use all 5 runs downstream?

That’s what the Include previous runs checkbox does. Turn it on, and the edge remembers everything.

┌──────────────────┐
│ Generate Image   │
│                  │     ┌─────────────┐
│  Ran 5 times:    │     │  Combine    │
│  [img1]          │ ──► │  Videos     │
│  [img2]          │     │             │
│  [img3]          │     └─────────────┘
│  [img4]          │
│  [img5] ← latest │
└──────────────────┘
  Edge pill: "all runs"  (all 5 flow through)

Picking specific runs

When the checkbox is on, a new text field appears — the runs selector. It uses the exact same syntax as the list selector, but it picks from runs instead of items.

You type	Result
(empty)	All runs pass through
`1, 3, last`	Only runs 1, 3, and the last one
`1..5`	Runs 1 through 5
`last-2..last`	Only the last three runs

The runs selector and the items selector work together. Runs are filtered first, then items. The edge pill shows both, like runs: 1,3 → items: 2..last.

Use Cases

Split text from an LLM, then process each piece

You asked an LLM for “5 scene descriptions for a short film.” The LLM returns one big block of text. You want to generate an image for each scene.

LLM ──► Split Text ──► [Each] ──► Generate Image
                                         │
                             (one image per scene)

Use Split Text to break the LLM output into a list, then set the next edge to Each.

Generate many, pick the best, continue

You want to generate 4 image variations and then only animate your favorite.

Generate Image (run 4 times)
       │
  [Include previous runs: on]
       │
    [Item: 3]                    ◄── your pick
       │
       ▼
Image to Video

Combine a batch into one final output

Generate 6 short video clips, then stitch them together.

Generate Video ──► [All] ──► Combine Videos
   (6 clips)                  (one final video)

Run a scheduled trigger against historic data

Your schedule trigger has fired 30 times (one per day). You want to regenerate the last 7 days as a weekly recap.

Schedule Trigger ──► [Include previous runs: last-6..last] ──► Generate Summary

Skip failed attempts

Your image gen failed twice in the middle of a 10-run session. You want to exclude those.

Generate Image (10 runs, #4 and #7 failed)
       │
  [Include previous runs: on]
  [runs: 1..3, 5, 6, 8..last]       ◄── skip the bad ones
       │
       ▼
Downstream processing

Best Practices

Start simple, then add modes as you need them

New workflows should start entirely in Selected mode. Only switch an edge to Item / Each / Bundle once you actually have a list of things to deal with.

One mode change at a time

When an edge isn’t behaving how you expect, change one setting, click Run, and see what happens. Ranges, lists, and “include previous runs” can stack on top of each other — changing several at once makes it hard to tell which setting fixed or broke things.

Match the mode to the downstream node’s job

Is the downstream node a transformer (one in, one out)? Use Each when the upstream has multiple items.
Is it a combiner (many in, one out)? Use Bundle.
Do you want just one specific result? Use Item.

Watch the edge pill

The pill label on the edge always tells you what’s happening in shorthand. A quick glance at the canvas can save you a trip into the menu:

Pill label	Meaning
(no pill)	Selected mode, default behavior
`2..last`	Range selector on Each/All
`1, 3, 5..last`	List selector on Each/All
`3`	Item mode, picking item 3
`all runs`	Include previous runs, no filter
`runs: 1,3,last`	Include previous runs, filtered
`runs: 1,3 → items: 2..last`	Both filters active

Keep an eye on credit estimates

Each mode multiplies the downstream cost by the number of items. If you fan out over 50 list items into a video generation node at 20 credits each, that’s 1,000 credits. The downstream node’s Generate button shows the total estimate — always check it before running.

Use Item mode for reproducibility

If you always want “the first image” or “the last video” regardless of how many results exist, Item mode with 1 or last is more reliable than guessing indexes. It also survives re-runs that change the total count.

Selected vs. Include previous runs

Selected = “the result you’ve currently picked.” Good for linear workflows where upstream runs once (or a few times) and you choose which output to pass along.
Include previous runs = “use the entire history of this node.” Good for aggregation, recaps, or combining work from multiple sessions.

Quick Reference Card

┌──────────────────────────────────────────────────────────┐
│                    EDGE MODE CHEAT SHEET                 │
├──────────────────────────────────────────────────────────┤
│                                                          │
│  SELECTED  one in  → one out     (default, active pick)  │
│  ITEM      many in → one out     (pick by index)         │
│  EACH      many in → many runs   (one by one)            │
│  BUNDLE    many in → one run     (all at once)           │
│                                                          │
│  List / range syntax:                                    │
│     1, 2, last         pick items 1, 2, and last         │
│     1..5               items 1 through 5                 │
│     1..last:2          every other item                  │
│     last..1:-1         reverse order                     │
│                                                          │
│  Note: "last" inside a range/list expression means the   │
│  final index — different from the Selected mode above.   │
│                                                          │
│  Include previous runs:                                  │
│     off     →  latest batch only                         │
│     on      →  entire history of this node               │
│     runs:   →  same syntax as list, but filters runs     │
│                                                          │
└──────────────────────────────────────────────────────────┘

Still stuck? Each edge dropdown has inline examples. And a malformed expression never crashes the workflow — it falls back to “all items” so you can keep experimenting safely.