Agent Orchestration: 7 Platforms, Temporal's Replay Narrower

Sixty percent is the quiet number in the 2026 orchestration debate: that share of n8n's enterprise customers chooses self-hosted deployments specifically for data control, according to growwstacks.com. The instinct behind that stat is the same one pushing agent orchestration away from free-form agent choice. The contrarian view gaining weight is that agentic systems fail when agents decide next steps; they succeed when every agent call is a replaceable activity inside a durable state machine.

The 2026 landscape already reflects this. Camunda describes its platform as orchestrating agents from the outside, injecting enforceable steps with policies, approvals, and escalation paths. Decisions markets itself around centrally orchestrating AI agents within governed workflows. Enterprises are also demanding a single pane of glass combining orchestration, observability, and metadata management, according to Hugo Lu's market analysis. The pattern: autonomy is dialed up per step, not granted as a whole workflow.

Temporal fits this narrower frame. Instead of graph checkpointers that can silently rewind after a worker crash, durable state machines replay deterministically and treat each agent invocation as an activity. That is why the practical fix for unreliable agent workflows often involves Temporal-style orchestration. The 60% self-hosting signal, taken alongside platform consolidation, points to a 2026 where control, not improvisation, defines agent orchestration.

The Mechanism

According to Temporal docs, a default hard limit caps the number of history events per workflow execution. That limit matters because of what a history event is: every activity invocation, every timer, and every child-workflow start is appended to the workflow's event history as it happens. When a worker crashes, Temporal re-executes the workflow function using the stored history — the code re-runs, but instead of actually invoking activities again, it reads the recorded results from the history. An LLM call that is an activity is therefore never re-invoked during replay. The LLM is a leaf, not the trunk.

LangGraph's mechanism is checkpointing, not replay. Every "super-step" writes the full graph state to an external checkpointer — Postgres or Redis, depending on configuration — and after a crash the graph resumes from that snapshot. What it lacks is a per-transition event log: there is no record of which external side effects completed before the snapshot, so LangGraph cannot prove that a side effect was executed exactly once. You get resumability, but not durability in Temporal's sense.

Camunda 8/Zeebe is event-sourced BPMN. Tokens move across a process model, and each token transition is written as an intent record to the Zeebe log, giving Camunda an audit trail without re-executing workflow code. According to Camunda, ProcessOS is "the open platform for agentic orchestration," blending straight-through processing for predictable steps with agent reasoning for exceptions, so autonomy can be dialed up or down per step. The agent still operates within a declared graph.

Airflow and Prefect are metadata-DB orchestrators. They persist DAGRun and TaskRun state in their own databases, but a failed Python task is retried from the top of its function, not from the last completed external call. Exactly-once behavior must therefore be built with idempotency keys outside the platform — the orchestrator cannot guarantee it.

The architectural line that determines the winner is whether LLM calls are activities or control flow. In Temporal, an LLM call is an activity that returns a value to a fixed graph; the workflow code is deterministic, and the LLM's output is just data flowing through it. In LangGraph, the LLM can add nodes at runtime, which is expressive but makes replay impossible when the workflow is long-lived, because the graph topology itself becomes non-deterministic. There is nothing stable to replay if the next step depends on a stochastic model's output.

Here is where the non-determinism failure that gives durable engines a bad name enters. When an LLM response is the input to the next state, Temporal requires you to send that response back via activity completion — the result is recorded in history before the workflow proceeds. If instead the workflow calls the LLM synchronously inside workflow code and reads the response directly, a replay after a crash will issue a second LLM call. That second call can return a different answer, and the workflow may branch differently from the path already recorded in history. Temporal will detect the mismatch and fail the workflow task. The fix is not to make replay smarter; it is to keep LLM calls inside activities and pass responses back as recorded events.

This kills the myth that "agent orchestration" means an LLM reads the full workflow state and picks the next action. In production, that pattern is exactly what makes complexity unmanageable, because a non-deterministic control path cannot be replayed, audited, or resumed after a crash. The durable parent workflow must be deterministic; the LLM's freedom belongs in the smallest leaf subgraph where a runtime choice is actually required.

The Evidence

AWS Step Functions is the only platform in the seven that publishes hard upper bounds on execution history and duration. According to the AWS Step Functions Developer Guide, Standard Workflows publish an execution-history cap and a maximum duration, while Express Workflows are capped at a shorter duration. Those are the only published upper bounds in the entire seven-platform set, and they are too low for long-lived agent loops with many LLM tool calls. Each activity invocation, timer, retry, and child workflow consumes multiple history entries, so a document-debate workflow with many model-backed tool calls per turn will burn through the Standard cap far before the business process ends. Express is a non-starter for long-running agent processes.

Temporal Cloud documents a monthly uptime SLA, and its replay-after-failure mechanism is what makes that SLA credible. Complete execution history is durably appended; on recovery, the worker replays from the last committed event and reconstructs state without re-running irreversible side effects. The contrast with LangGraph is sharp: LangGraph’s docs do not publish a workflow-semantics uptime SLA because its checkpointer is an application-side library, not a platform service. That is the real boundary line. This also kills the myth that agent orchestration means an LLM reads the full workflow state and picks the next action. A non-deterministic control path cannot be replayed, audited, or resumed after a crash—there is no single committed event from which to resume.

Zeebe’s own documentation claims a high-volume instances-per-second stress benchmark, but the benchmark setup assumes pre-deployed BPMN models with no LLM calls in the hot path. Those assumptions make Zeebe strong for high-volume, regulated processes where the control flow is fixed. They do not transfer to a group of agents debating a document, where each turn is an unpredictable model call and the document state changes the available choices.

Ray’s docs state that Ray clusters have been run at large scale in production, and the same docs call Ray a “compute substrate,” not a workflow engine. That is why every credible Ray-based agent stack wraps Ray workers in a Temporal or Step Functions parent graph. Ray owns the parallel compute; it cannot own the durable control plane.

As of a GitHub API snapshot in 2026, the open-source platforms in the comparison can be ranked by community attention; AWS Step Functions has no public repository. The ranking is a useful community-attention signal, but it does not predict the reliability properties this guide weights for a durable parent graph.

Read together, the documented limits, SLAs, and benchmark assumptions all point the same direction: Temporal is the only platform with the durability and replay semantics to be the parent graph, while LangGraph belongs at the leaf where a model must genuinely choose the next step at runtime. When you can declare the control flow in advance, the evidence says to declare it.

The Decision Framework

Temporal leads the Decision Framework scoring, followed by AWS Step Functions, Camunda 8/Zeebe, LangGraph, Prefect, Ray, and Airflow. The gap between Temporal and LangGraph is the cost of letting an LLM own the control path instead of the durable log.

This kills the production myth that "agent orchestration" means an LLM reads the full workflow state and picks the next action. A non-deterministic control path cannot be replayed, audited, or resumed after a crash. The canonical decision rule: Temporal as the durable parent graph; LangGraph only at the smallest subgraph in which an LLM must choose the next step at runtime. If you can declare the control flow in advance, declare it.

The criteria are weighted, with deterministic replay, state inspection, failure isolation, human-in-the-loop, LLM-native primitives, and operational overhead. Replay and state inspection dominate because they decide whether a parent workflow is recoverable and auditable; LLM-native syntax is deliberately the smallest line item.

Temporal wins on the highest-weighted criteria: full deterministic replay and a complete event history for audit, plus child-workflow failure isolation and native human-in-the-loop primitives. Step Functions is second — IAM-native security and zero infrastructure are strong, but its serverless boundaries reduce both state-inspection and human-in-the-loop scores.

LangGraph's placement is the instructive one: it owns the strongest LLM-native primitives, yet loses to Temporal because its graph state is not a durable event log. The other platforms are not eliminated; they are repositioned. Camunda 8/Zeebe serves regulatory BPMN; Ray scales to large-scale inference fan-out but lacks workflow semantics. Prefect and Airflow fit stateless data DAGs — Airflow's weak resumability and Ray's missing workflow semantics are the biggest single gaps. Step Functions remains the AWS-native simple-state-machine call.

So the 2026 decision is not "which agent framework." Ask whether the step can be declared in advance. If yes, put it in Temporal (or Step Functions, if you are AWS-native and the state machine is simple). If no — an LLM must choose among a bounded set of next actions at runtime — hand that one leaf to LangGraph. Declare the parent, delegate the leaf, and let the durable event log be the source of truth.

What the Data Doesn't Tell You

Temporal's replay guarantee is narrower than its marketing implies. It covers workflow code only, not the activities that touch the outside world. When an activity calls an API and the response is lost, Temporal retries the activity; if that call lacked an idempotency key, the retry charges twice or writes a duplicate row. The durable event history records that the activity ran, but it cannot make the external side effect atomic. This is the biggest counter-evidence: the parent graph is durable, while its leaf activities are at-least-once by default, and no durable engine fixes that.

Vendor benchmarks conceal the second failure mode because they run frozen code. According to Stanford production tracing data, Temporal incidents include non-deterministic workflow errors caused by code changes during an open workflow. The replay mechanism regenerates workflow tasks from event history; if deployed code no longer matches the code that emitted those events, the history becomes unreadable. Real-world failure rates therefore look higher than the documentation suggests. The countermeasure is to freeze workflow code and push changeable logic into activities, but the tracing data indicates teams rarely do it cleanly. That maintenance tax is the real price of a durable parent.

LangGraph's lack of durable replay is the standard reason to reject it at parent scope. At the leaf, that weakness becomes a feature. Leaf code changes, including prompt edits and node logic, do not trigger non-deterministic-error replay because no long-lived workflow state exists to corrupt. For short-lived agent sessions, LangGraph is the better leaf: the session either finishes or the Temporal parent re-runs it. The durability burden stays outside the LLM's non-deterministic step.

Workflow-shape data cuts both ways, but not toward LangGraph-first. Closed-loop workflows — approvals, claims, screening — win with Temporal as parent. Open-ended workflows such as open-domain research agents show higher task completion when the agent loop can try multiple tools. The correct reading this year is not "use LangGraph instead"; it is to place that open-ended loop in one LangGraph child and keep a durable Temporal parent around it. The parent supplies the audit trail and resume point even when the child's reasoning path is unrepeatable. An LLM reading full parent state to choose the next action is precisely the pattern that cannot be replayed after a crash; it belongs in the leaf, nowhere else.

Cost figures miss variance too. A Temporal child-workflow design that cleanly avoids the hard history limit can still create many children, and each child's history poll interval keeps workers alive even when idle. In one production cost trace, child-workflow overhead added to infrastructure spend that a monolithic Step Functions Express run did not have. Pricing-model variance is equally wide: Orchestra claims no additional orchestration licensing and no per-user, per-pipeline, or orchestration platform fees, according to Data Orchestration 101, while per-child and per-poll costs hide inside Temporal-style designs. Deployment variance compounds it: over 60% of n8n's enterprise customers self-host for data control, per growwstacks.com, while Zapier still offers no self-hosting as of this year. Any cost comparison that ignores these dimensions measures one slice of a bimodal distribution.

The edge cases below change the implementation, not the architecture.

Decision for this edge-case set: keep Temporal as the parent for anything that must be resumed, audited, or replayed, and accept the maintenance tax by freezing workflow code. Idempotency keys are non-negotiable at every activity boundary; confine non-determinism to the LangGraph leaf. The thesis holds — the premium is justified when you engineer for it, not when you assume the platform provides it.

Worked Case

A Stanford medical informatics group's living systematic-review pipeline is the cleanest production proof of the Temporal-parent / LangGraph-leaf split. The Temporal parent workflow `ReviewBatch` declares its control flow and never consults an LLM: pull from journal RSS feeds, screen and extract PubMed abstracts each week, emit the batch result. PubMed's MEDLINE base changes over time, so the pipeline samples a moving corpus, not a fixed one. Each abstract becomes one Temporal child workflow (`ScreenAbstract`) running several agents — relevance screener, PICO extractor, inclusion-criteria matcher, risk-of-bias tagger, contradiction-checker, report writer — but each agent is a LangGraph subgraph invoked as a single Temporal activity, not as a Temporal workflow node.

That one boundary — LangGraph inside the activity, never as the workflow node — is why the history stays small. In the group's measured batch, the parent workflow carried a history made up of child completions plus parent task events, each child carried a smaller history, and the highest per-execution count stayed below the history-event ceiling discussed above, so no Continue-As-New was needed. If the agents had been Temporal workflow nodes instead of activity payloads, each abstract would have multiplied the parent's history, and the batch would approach the limit on a heavy week. Instead, Temporal records one activity event per agent, and the LangGraph subgraph's internal nodes never enter the durable history.

The contradiction-checker's LangGraph leaf is the only nondeterministic step in the pipeline. At runtime it chooses among 'escalate to human,' 'cross-check second model,' or 'accept.' In the group's trace, that branch sometimes made the wrong choice. That rate is the whole argument: the same error rate at the orchestration layer would corrupt an entire batch, but an error at a leaf inside a durable parent fails exactly one `ScreenAbstract` child and leaves `ReviewBatch` untouched. The parent records the child's outcome as a history event and moves on.

This inverts the myth that agent orchestration means an LLM reads the full workflow state and picks the next action. The parent reads event history, not LLM state. The LLM gets exactly one decision it cannot avoid, exactly one leaf. Everything declarable is declared.

The winner is the boundary itself: Temporal owns every control decision that can be declared, and LangGraph owns only the one decision that cannot. The leaf error rate is survivable precisely because it is a leaf.

The most expensive decision in an agent build is not the model — it is who owns the retry. The default instinct treats "agent orchestration" as an LLM reading the full workflow state and choosing the next action at every step. In production, that pattern makes complexity unmanageable: a non-deterministic control path cannot be replayed, audited, or resumed after a crash. Orchestration instead relies on a central controller that manages, initiates, and coordinates communication, with each microservice communicating only with the orchestrator (Dnyandeo Bharambe / Medium). That controller must be a durable state machine — the single pane of glass enterprises want across orchestration, observability, monitoring, metadata management, and agents (Hugo Lu / Medium).