Advanced Orchestration Control
The runtime layer that decides what runs, when, how many at once, and what happens on failure. Branch on output, retry flaky steps, cap concurrency, loop until done, gate on a human — wired on the canvas, enforced on every run.
A chain is a program. These are its control structures.
A chain runs top-to-bottom — Initialiser → Investigate → Plan → Create → Review — each node handing its output downstream. That's the happy path. Real work isn't a straight line.
Control flow lives on the edges and each node's policy — not in a prompt — so it's deterministic, inspectable, and version-controlled with the canvas. The eight primitives below are how you bend the straight line into real work.
Branch on output.
An Evaluate node scores the work; the edge that fires depends on the score. Pass → ship. Fail → loop back to Create.
Survive flaky steps.
A node that errors retries with backoff. Exhaust the budget and the run hands off to a fallback node — a cheaper model, a cached result, or a safe default.
Cap what runs at once.
A Parallel fan-out can spawn twenty branches — but a limit of 4 keeps you inside rate limits and budget. The rest queue.
Repeat until done.
Iterate a sub-chain over a list, or loop Create → Evaluate until the score clears a bar — bounded by a max-iteration guard so it always terminates.
Nest whole graphs.
Collapse a multi-node flow into one node. The parent sees a single step; inside lives a complete canvas with its own routing and policies. Reusable, testable, portable.
Per node, on failure.
Each node declares what failure means: fail-fast stops the run, continue routes downstream anyway, isolate contains it to its branch.
Human in the loop.
A Review node pauses the run and waits for a person. Approve to release downstream nodes; reject to route back. Nothing risky runs unattended.
No silent hangs.
Fence every node in wall-clock time. Exceed the budget and the node is cancelled and handed to its error policy — so a stuck Deploy never freezes the whole graph.
Run the same chain three ways.
Pick a scenario, press Run, and watch routing, retries, the concurrency cap, a timeout, and a human gate decide the path live. Same chain — the outcome changes with the output.
This runs the runner's real logic, just sped up.
The difference between a demo and production.
A chain that only works when nothing fails is a toy. Control flow is what survives real models, real rate limits, and real money.
Same input, same path.
Logic is edges and policies, not a prompt — so a run is reproducible and the whole control flow reads at a glance.
Concurrency caps the bill.
A limit of four on a twenty-branch fan-out holds spend and rate limits in check; backoff keeps a blip from becoming a storm.
Failure has a plan.
Every node has a timeout and error policy. A stuck step is cancelled, retried, or sent to a fallback — the run degrades, never hangs.
Sub-canvases keep big graphs sane.
Collapse a tested flow into one node, reuse it across canvases, version it as a file, and swap its internals without touching the parent.
A human where it counts.
A Deploy, an Apply, an outbound message — each pauses on a gate until someone approves. Automation where it's safe, a checkpoint where it isn't.
Pairs well with
Agentic Streaming
Deploy 20 agents on one task — parallel fan-out, the concurrency cap in action.
openCanvas Planning
Lay out goals, phases, and milestones — the structure the control flow runs on.
openTesting Pipeline Nodes
Drop test nodes into the chain and assert on any output — gate on green.
open