Run Flow Node
The Run Flow Node calls another flow entry and returns to the current flow when it's done.
What it serves
Think of it as import for flows. When the flow you're building gets too large to read on one canvas, break it into smaller flows and call them via Run Flow. Each Run Flow node is a shortcut to a portion of logic defined elsewhere.
When execution reaches a Run Flow node:
- The engine looks up the entry given on the node (e.g.
MyFlow-StartNode). - It runs that flow.
- When the called flow finishes, control comes back to this flow and continues out the OUT edge.
Visual
A simple node with two dots — IN on the left, OUT on the right. The body shows a green "linked rectangles" icon (the Run Flow symbol).
Settings
Click the node to open Run Flow Node Settings:
| Field | Purpose |
|---|---|
| Flow Name | The entry to call, in <Controller>-<StartNode> form. Example: MyFlow-StartNode. |
| Node Description | Free-text — for other developers. Doesn't affect execution. |
| Apply | Saves the settings. |
How dictionary is shared
The called flow runs against the same dictionary instance as the calling flow. Anything the called flow's nodes write to the dictionary is visible after the Run Flow node returns.
There's no argument-passing or return-value mechanism beyond the shared dictionary — write what you want to pass before the Run Flow node, read what came back after it.
Failure behaviour
If the called flow fails, control does NOT come back. The error propagates and the parent flow fails too.
There's no "error" edge on Run Flow — just IN and OUT. If you need to recover from failures, handle them inside the called flow (e.g. with a Script Node and its error edge) before letting the flow finish.
When to use it
- A piece of logic is used in more than one flow → extract it once, call it via Run Flow from each caller.
- A flow has grown too dense to read at a glance → split sections into named sub-flows and chain Run Flow nodes.
- You want each piece testable on its own — a sub-flow can be debugged in isolation just like any other flow.
When to reach for something else
- Need to fan out over a collection? Use Parallel Flow instead — Run Flow is one-shot, sequential.
- Want to leave the current flow without coming back? Use Jump Flow — Run Flow always returns; Jump Flow doesn't.
- Want different paths on success vs failure? Wrap the call's failure in a Script Node inside the called flow.
Example wiring
[Start Flow] ──► [Run Flow: MyFlow-StartNode] ──► [End Flow]
The Run Flow node sits inline like any other — input from upstream, output to downstream. The "real work" lives in the file/flow named on the node.