Merging

A ⋈ Merge node combines several inbound text wires into one result, using a strategy you choose.

It is the fan-in counterpart to parallelism’s fan-out.

Three agents on different providers each produce an answer; a merge combines them by majority into one output.

Three opinions, one answer. Without the merge, those three texts would arrive at the output joined by blank lines.

Why it exists

Wire three agents into one output and threadle joins their texts with blank lines — quietly — if that input still has capacity. Many transforms (Delay, Text → Prompt, …) only accept one inbound wire; dumping three agents onto an output is refused. A merge is the intentional multi-in merge you can see on the canvas.

Strategies

Strategy	Behavior	Good for
concat	Join candidates with a separator	Collecting sections written in parallel
first	Take the first inbound text	Fastest-wins races, fallback chains
majority	The most common answer wins	Verification — “do 2 of 3 agree?”
synthesize	Build a labeled candidate prompt; with a model set on the node, run it to write the synthesis	Turning N drafts into one text

Empty inbound texts are ignored before merging, so a starved branch doesn’t blank your result.

Synthesize in detail

With no model set, a synthesize merge emits the labeled candidates plus an instruction to merge them — useful as the prompt body for a downstream agent:

### candidate 1

…

### candidate 2

…

---

Synthesize the candidates above into one coherent result.
Prefer agreement; note conflicts briefly.

Set a provider and model on the node and the merge node runs that model itself, emitting the finished synthesis. The run log records which model did the merging.

Wiring

Any text producer → merge → any text consumer. Merges chain: a majority merge over three agents can feed a synthesize merge alongside a fourth opinion.

A merge requires at least one inbound wire; an unwired merge is flagged by graph lint and blocks a detached run.

Patterns

Verify by vote. Same prompt → three agents → majority merge. Cheap, and it catches the case where one model confidently invents something.

Cross-provider synthesis. Claude, opencode and Cursor answer the same question; a synthesize merge with your preferred model writes the merged answer. Only threadle can wire that in one graph.

Fallback chain. Primary and backup agents into a first merge, so a failed primary doesn’t stop the run.

Examples

▶ Merge concat and Merge first-wins — no agent required. ▶ Parallel fan + majority merge — parallel asks merged by vote.

Parallelism — running the branches in parallel
Lanes & value types — what happens without a merge
Iterator — the one-to-many counterpart