Parallel Flow Node

The Parallel Flow Node is the per-branch spec used inside a Parallel Node. One Parallel Flow per parallel branch — each one names a flow to run and configures how that branch's dictionary inherits from the parent.

This is not a standalone iteration node. It only makes sense when wired into a Parallel Node's WAIT dot.

What it serves

When the parent Parallel Node fires, every connected Parallel Flow starts simultaneously. Each one:

1. Begins a fresh sub-flow at the entry named in Flow Name.
2. Runs against a brand-new dictionary — its own scope, isolated from siblings and from the parent.
3. Optionally inherits some or all of the parent's dictionary via the inheritDictionary property — see Three inheritance modes.
4. Runs to completion. Its final dictionary becomes one entry in the parent Parallel Node's Assign To array.

Visual

The node has one dot — OUT on the left, connecting to the parent's WAIT. The body shows a clock-like icon.

Settings

Click the node to open Parallel Flow Node Settings:

Field	Purpose
Flow Name	The entry to run — same <Controller>-<StartNode> form as Run Flow.
Use Parent Dictionary	Checkbox. When ON, the sub-flow's dictionary gets an inheritDictionary property pointing at the parent's dictionary (or a slice of it).
Dictionary Key	Optional. When set together with Use Parent Dictionary, only the parent's value at that key is inherited (not the whole parent dictionary).
Node Description	Free-text — for other developers.
Apply	Saves the settings.

Three inheritance modes

Use Parent Dictionary	Dictionary Key	What the sub-flow sees
OFF	—	inheritDictionary is not set. Sub-flow has a clean, empty dictionary.
ON	empty	dictionary.inheritDictionary = the whole parent dictionary.
ON	someKey	dictionary.inheritDictionary = parentDictionary.someKey || {} — just that slice.

The sub-flow has its own scope. Whatever it writes to its own dictionary.* does NOT mutate the parent. Cross-branch isolation is guaranteed.

Each branch also gets its own sessionID (with parentSessionId set to the parent's session). This is the key contrast with Parallel Context, where the session is shared across all clones — here every Parallel Flow branch runs in a fresh session of its own.

Engine-injected fields the sub-flow sees

• __callContext is NOT auto-injected for Parallel Flow branches. Only Parallel Context clones auto-set __callContext: 'tool' (and caller: 'parallel'); a Parallel Flow branch does not get these automatically. If you need tool-routing semantics inside a Parallel Flow branch, set __callContext yourself.
• The caller: 'parallel' field is likewise confirmed in source only for Parallel Context clones — do not assume it is present on Parallel Flow branches.

Setting __callContext: 'tool' manually

__callContext: 'tool' is the property that makes an Agent Node's response land in dictionary.result instead of being appended to the agent's prompt stack. Because Parallel Flow branches don't auto-inject it, set it explicitly:

1. Drop an Assignment Node at the start of the sub-flow that sets __callContext = "tool".
2. Run the Agent / Script / whatever needs the tool semantic.
3. Drop another Assignment Node before the sub-flow ends to clear or change it if downstream nodes inside the same sub-flow shouldn't see it.

Wiring

   ┌─────────────────────────┐
   │     Parallel Flow       │
   │  Flow Name:             │
   │  "MyFlow-Variant1"      │
   │                         │
   │           OUT  ◀────────┼────►  Parallel.WAIT
   └─────────────────────────┘

Each Parallel Flow is independent — different Flow Name, different inheritance settings, different end. The parent Parallel Node collects whatever each branch's final dictionary looks like, in wiring order.

Comparison

Need	Use
Run the same flow over a dynamic-length collection	Parallel Context
Run a fixed set of differently-named flows in parallel	Parallel Node + this node, one per branch
Call a sub-flow once, synchronously, sharing the parent dictionary	Run Flow
Hand off to another flow without coming back	Jump Flow

Related

• Parallel Node — the parent. Required.
• Parallel Context — when count is dynamic and the flow is fixed.
• Run Flow — same Flow Name shape, but synchronous and shares parent's dictionary.
• Assignment Node — used as the workaround for __callContext.