Last night, we put a conductor in front of our agents, with five patterns in our pocket. But a conductor follows a score that runs left to right — and the real world doesn’t run left to right. If the tests fail, go back. If the case is sensitive, call a human. Wait until those two are done before moving on. A score doesn’t know how to write that.
You know what does? The railway network: stations, tracks, switches that send the train left or right depending on the load, return loops, mandatory stops at the control station. Describing orchestration as a network of rails is graph-driven agent orchestration — the approach every framework is converging on. All aboard — it’s not rocket science.
What the score can’t write
Take yesterday’s patterns again: the pipeline is a straight line, the fan-out a fan. As long as the route is known in advance, all is well. But as soon as real flow shows up, the line breaks:
- the condition: “if the review finds a critical issue → back to the developer; otherwise → deploy”;
- the loop: “regenerate while the tests fail — but no more than three times”;
- the junction: “the synthesis only leaves once all three reviewers have handed in their copy”;
- the station stop: “before merging, a human approves” — the checkpoint from two days ago, promoted to a citizen of the flow.
You can bury all of that in a lead agent’s prompt and hope. Or you can lay it on rails: that’s exactly the choice we’re about to tool up.
The network, piece by piece
An orchestration graph uses the same grammar as yesterday’s knowledge graph — nodes and edges — but with a completely different meaning:
- A node = a station, that is, a step. And surprise: anything can be a station — an agent (probabilistic), a classic function (deterministic: parse, validate, count), or a human (the control station where the train waits for the green light).
- An edge = a track, the transition from one step to the next. An edge can be unconditional (always this track) or carry a switch: a condition, evaluated on what the train is carrying.
- The state = the freight car. What travels from station to station: the diff to review, the accumulated verdicts, the retry counter. Each station reads the car, adds to it, sends it back down the track.
- The loop = the return track — allowed, but bounded (three laps max), otherwise you’ve just built a merry-go-round.
- The checkpoint = a photo of the freight car at the station. State is persisted at every step: if the network goes down at station 7, you resume at station 7 — not back at the depot.
Yesterday’s five patterns, seen from above
Gain some altitude, and look at yesterday’s patterns as network shapes: the pipeline is a straight line; the fan-out, a star that diverges then converges at a junction; orchestrator-workers, a star whose branches are decided en route; the handoff, a switch whose decision belongs to the station; the judge panel, a star converging into a voting station.
That’s the article’s lightbulb moment: the five patterns aren’t five different tools — they’re five shapes of the same graph. That’s why frameworks converge: offering the graph means offering every pattern, plus every one you’ll draw yourself.
Why rails change everything
The deep benefit fits in one sentence: determinism takes back the structure, the probabilistic stays confined to the stations.
- The structure becomes code: versioned, reviewed in PR, testable — and drawable. An orchestration graph writes itself as a diagram as code: the doc and the execution are the same thing.
- Observability comes for free: every edge crossed gets logged. Yesterday’s “debugging by ear” becomes reading an itinerary: the train went through these stations, in this order, with this freight.
- Recovery is native: thanks to checkpoints, an incident only costs the current step — precious when the full journey runs in hours and tokens.
- The human gets a station of their own: human-in-the-loop is no longer a “remember to ask” in a prompt, it’s a node — the train cannot pass without the green light.
Tool-wise: this is the model of LangGraph — which popularized the name — and, in our .NET world, of Microsoft Agent Framework’s workflows: executors (the stations) connected by conditional edges (the switches), with state and checkpoints. Copilot’s subagents, seen this morning, are the simple star; the graph is the generalization.
Two graphs — don’t mix them up
This week made you cross paths with two graphs — and the confusion would be easy:
| Knowledge graph (yesterday) | Orchestration graph (today) | |
|---|---|---|
| The nodes are | entities (Payment, ACME) | steps (agents, code, humans) |
| The edges are | relationships (depends on) | transitions (on failure, go back) |
| The graph describes | what the AI knows | what the agents do |
| You traverse it to | answer | execute |
And they snap together naturally: inside a station of the execution graph, an agent may well query the knowledge graph — the detective consults his board while the train is running. Two mechanics, two roles, zero rivalry.
A word of honesty
Rails have a price, and the ticket isn’t cheap:
- Over-engineering lurks. Three stations in a straight line = a pipeline = thirty lines of script. The graph only starts paying with switches, loops or recovery. Drawing a railway cathedral for a one-way trip is the classic first-project trap.
- Shared state is a craft. The freight car everyone reads and writes is the problem of distributed systems — write conflicts and ballooning state schemas didn’t vanish because we said “agent”.
- Rails constrain. An agent on rails will never take the brilliant shortcut its freedom would have allowed. It’s a deliberate trade: flexibility for predictability. For a production flow it’s almost always the right trade — but make it with your eyes open, and measure it.
The practical advice: draw on paper first. If your marker never draws a diamond (condition) or a return arrow (loop), put the framework away — a script will do.
In short
- The orchestration graph = stations (agents, code, humans), tracks (transitions), switches (conditions), freight car (state), photos of the car (checkpoints).
- Yesterday’s five patterns are five shapes of the same graph — learn it once, own them all.
- The deep win: deterministic structure, confined judgment — traceable, resumable, drawable, with the human as a real station.
- Don’t mix up this week’s two graphs: one knows (knowledge), the other does (execution) — and they snap together.
- The graph pays when there are conditions, loops or recovery — otherwise, an honest script does the job.
Yesterday’s conductor improvised with talent; today he has a network map in front of him — and you now know how to read both maps of the week: the one of knowledge, the one of work. Next time a train of agents derails at 3 a.m., you’ll know exactly which station to look at. And that, honestly… is not rocket science.
