What counts as agent orchestration — a checklist the category keeps dodging

October 17, 2026

Ask for an agent orchestration tool and two different products answer. The automation platforms — Zapier, Make, Workato, n8n — claim the word for pipelines that move data between SaaS apps. The frameworks — LangGraph, CrewAI, AutoGen — claim it for code that coordinates LLM-powered agents. Both are right about their own half, and the marketing has blurred the term until it means almost nothing.

So here's a concrete version: what a tool has to do before “orchestration” is honest. Not a LiveGraph pitch — a checklist. The LiveGraph column is at the end, and it's the easy part to write because the product was built around this list.

The checklist

• An explicit graph. Nodes are agents or tools; edges are routing — including conditional routing and fan-out. The topology is a thing you can point at, not control flow buried in a script.
• Durable runs. A run survives restarts, resumes at the failed hop, and an orphaned run is detected rather than silently lost. Schedules, webhooks, and API launches are first-class citizens alongside interactive ones.
• Multi-agent patterns. Hierarchies and delegation, fan-out and join — consensus, map, spawn — as primitives, not patterns you rebuild in glue code.
• Dynamic replanning. Where the run goes next is decided during the run — from model output, from runtime state, from a human — not fixed at compile time.
• Human gates that don't kill the run. An approval parks execution mid-run; approving resumes it. A gate that means “abort and start over” isn't a gate, it's a cancel button.
• Observability while it runs. Live state — which hop is active, what it's doing — not a log you read afterward. If you can't see the run, you can't operate it.

Why the automation platforms aren't it

Zapier and Make are excellent at what they are — and what they are is data plumbing. A Zap is a trigger and a linear list of actions; a Make scenario is modules on a canvas. That's choreography of apps, not orchestration of agents: no run state to checkpoint, no per-hop routing decided by a model, no multi-agent delegation, and — as the Zapier/Make comparison covers — no surface for changing where a run in flight goes next. When these platforms add an “agent” step, it's a model call inside the same frozen pipeline. The pipeline is still the product.

Why the frameworks only get halfway

LangGraph, CrewAI, and AutoGen genuinely orchestrate agents — explicit graphs or crews, real routing, real state. What they don't orchestrate is operations. The topology is compiled into your codebase: a routing change is a code change, a review, a redeploy — it applies to the next invocation, never the one in flight. LangGraph lets you edit a paused run's state, which is real; the run's route stays frozen (detailed comparison). And when the thing running is a black-box crew, the answer to a hop going wrong is to start the run over.

That's the gap the checklist exposes: every tool gives you the graph before the run. None of them give it to you during it.

Where LiveGraph sits on it

LiveGraph was built as the operating half of orchestration — the checklist is its feature list, so the mapping is short:

• Explicit graph — the topology is data on a live canvas: nodes as agents, edges as routing, visible while it executes.
• Durable runs — run state is persisted per hop; a failed run resumes at the failed node, a run with no live worker is swept and marked, and schedules, webhooks, and API launches run the same engine as the canvas.
• Multi-agent patterns — hierarchies, delegation, and fan-out/join (consensus, map, spawn) are graph primitives, including graphs dispatched into other graphs.
• Dynamic replanning — the engine dispatches one hop at a time and re-reads the graph after every model call, so dragging an edge mid-run changes where this run goes next. Unattended runs start pinned — snapshot semantics for reproducible reruns — and the run you're watching runs live.
• Human gates — approvals park the run mid-flight and resume it on decision; a risky tool call parks fail-closed rather than executing blind.
• Observability — the canvas is live during the run, and a shareable read-only view lets someone else watch it without seeing hop contents.

The honest asymmetry: LiveGraph is deliberately not a connector catalog — the iPaaS tools' thousands of pre-built integrations aren't the job it was built for. And being an ops surface rather than a library means it orchestrates agents against your systems, not as a framework inside your codebase.

The one-line version

Agent orchestration is running a graph of agents you can see, gate, and steer — while it runs. If the checklist is what you're actually after, watch the canvas steer a live run — scripted model, no account, no API key.