About this site

Agent Orchestration Explained treats multi-step and multi-agent systems as discrete-event systems. Its first four chapters take apart LangGraph's execution model (graphs and super-steps, state with reducers, checkpoints, interrupts and time travel) and durable execution (replay, non-determinism, idempotency keys); the next five model multi-agent patterns, fan-out under a rate limit, reliability, many workflows sharing one endpoint, and how to choose between the patterns from the simulation. Every chapter is built around an animation. It is the fourth of a family of agent sites, after Agent Harnesses Explained, Agent Protocols Explained and Agent Context Explained, next to the LLM-systems sites (the Transformer Decoder Explainer, LLM Inference Explained, Inference Trade-offs Explained and others, all in the header's switch).

Checked against real LangGraph

The engine's graph runtime is a model of LangGraph's, not a reimplementation of its code: graphs are data, and each node's behaviour is a short list of deterministic operations. In the engine's CI, every one of 39 sessions is built as a real StateGraph (plain node functions, operator.add and a max reducer, LangGraph's own interrupt, an in-memory checkpointer) and run in langgraph 1.2.14 (langgraph-checkpoint 4.2.0, pinned). After each of the 71 operations (invokes, crashes, resumes, Command(resume=…), update_state, time travel, Send fan-outs) the whole checkpoint history is compared with the engine's: every checkpoint's step, source, parent, state, next tasks, and each task's result, error and interrupt. They are equal. The data page lists the sessions.

One LangGraph detail turned out not to be deterministic: whether a checkpoint's next lists a join target whose other inputs have not arrived (it did in about nine runs in ten here). That task never runs from that checkpoint, so the comparison leaves it out on both sides; everything else is compared as recorded.

The engine, and how the animations are checked

The engine is Agent_Loop_Sim's orchestration module (engine 1.11.1): a Python reference with a TypeScript port, vendored here at commit 46b445c with every file's SHA-256 recorded. It runs in your browser in a few milliseconds, except the load sweep of chapter 8 and the chooser's tables of chapter 9 (thousands of simulated workflows), which the same engine computes when the site is built. Agreement between the two languages is exact, with no tolerance: every checkpoint, frame, caption, durable-execution run and seeded sweep.

• In CI, the Python reference installed from the vendored commit regenerates this site's fixtures (everything each chapter animates), and the unit tests require the vendored TS engine to reproduce them exactly.
• Every number in the prose is computed by the engine when the page is built, never typed in.
• Every code block in a chapter is cut from the vendored engine or from the LangGraph builder the conformance check uses, and every equation compiles; end-to-end tests play, step, scrub and reset every animation in light and dark mode at desktop and phone widths, and check its captions at key steps against the Python reference's frames.

What is illustrative

• Node durations and the 15 ms checkpoint write (chapter 1 and 2's timings). The order of writes, what each node sees, which nodes run in which step, and every checkpoint are LangGraph's.
• The graphs, their state and their side effects (an API call, a notification, an email, a git push) are invented.
• Chapter 4's workflow, payment service, shipping cut-off and times (a 2,000 ms reply timeout, a 5,000 ms restart). Its event history is simplified, in the style of durable-execution engines such as Temporal, not any engine's format. Its closed forms are exact under their stated assumptions, and checked against a seeded simulation.
• Chapters 5–9: the task, every token size, the accuracy model (a call right with probability 0.98 up to 4,000 prompt tokens, losing a chosen amount per 1,000 tokens beyond; 0.995 for a routing decision), the debate's first round charged but not credited, the rate limits (50 requests, 40,000 input and 8,000 output tokens a minute: small, workspace-style limits, far below the Claude API's standard tiers), the transient failure rate, timeouts, backoff and jitter, and the reliability chapter's error rates and verifier. Prices are the engine's dated list prices; latency is its hosted profile. The rate limiter follows the token-bucket scheme the Claude API documents, with a client that waits for capacity; an errored attempt is not billed and a timed-out one is (assumptions). The simulation's mechanics (queueing, buckets, retries) and the closed forms are exact; the numbers describe no real system.

Accessibility

Every animation has keyboard controls (Space plays or pauses, the arrow keys step), a live caption read out by screen readers, and starts paused when the reader prefers reduced motion. Colours come from Okabe and Ito's colour-blind-safe palette, and nothing is told by colour alone: a failed node is also hatched and crossed, a paused one marked, a changed value tagged.

Source

The site's source is on GitHub (MIT). For the slides behind the chapters, see Introduction to LangGraph.