Yesterday we assembled an orchestra: a conductor agent that decomposes a big task and dispatches it to specialist agents. But our conductor had a peculiarity: it was improvising. At every moment, a model decided live who plays next. Flexible, yes. Predictable, reproducible, auditable? Not really.
Today we hand the conductor what every real orchestra plays from: a score. Written in advance, with movements, repeat signs and alternate endings. In technical terms: graph-driven agent orchestration, where the possible sequences between agents are drawn as a graph before the concert. If you’ve read our piece on graph engineering, you know the rails; today we put whole orchestras on them. You’ll see: it’s not rocket science.
Two ways to conduct the same concert
Multi-agent systems are conducted in one of two ways, and the difference is exactly the one between jazz and symphony:
- The jam session (supervisor-driven). A bandleader agent looks at the state of the piece after every phrase and decides, live, who plays next: “researcher, again”, “writer, your turn”. Each decision is a model call, with a model’s creativity and a model’s whims. Two runs of the same task can follow completely different paths, and the token meter runs during every decision.
- The symphony (graph-driven). The sequences are written down in advance: after research comes writing, after writing comes review, if the review fails we repeat, twice at most. The conductor still makes calls, but only where the score marks a choice. Everything else is ink on paper: deterministic code, not a model’s mood.
The score doesn’t remove the musicians’ talent. Inside each movement, the agent keeps its full agentic loop, its tools, its autonomy. What the score removes is improvisation between movements: who plays when is no longer up for debate at runtime.
Reading the score
Remember the four words of graph engineering? They translate to music directly. The node is a movement, and in agent orchestration each movement contains a complete agent, not just one model call. The edge is the order of movements. The conditional edge is the alternate ending: first time through, repeat; second time, move on. And the state is the shared score everyone annotates: the brief, the research notes, the draft, the review verdicts. Each agent reads it, plays its part, writes its result back.
Here’s yesterday’s newsroom, rewritten as a score:
flowchart TD
B([Brief]) --> P[Plan the study]
P --> R1[Researcher: competitors]
P --> R2[Researcher: regulations]
P --> R3[Researcher: reviews]
R1 --> M[Merge the notes]
R2 --> M
R3 --> M
M --> W[Writer: draft]
W --> V{Editor: review}
V -->|needs work, max 2| W
V -->|approved| H{Human sign-off}
H -->|changes requested| W
H -->|approved| E([Publish])
Every trick of a real score is in there. The three researchers are a tutti: sections playing at the same time, and the “merge” movement waits for all three, a barrier, before the writer starts. The “needs work” arrow is a repeat sign with a hard cap written in ink: two passes, then we move on no matter what; no improvised infinite loop. And the human sign-off is the fermata: the point where the conductor holds everything, baton in the air, until a human gives the cue. Human-in-the-loop, guaranteed by the score rather than promised by a prompt.
What the written score buys you
Compared to yesterday’s jam session, four things, and the first one is the sleeper hit:
- You can resume at bar 42. A long orchestration fails at step 7 of 9, an API times out, a human takes two days to approve. With a jam, you replay the whole concert. With a graph, the annotated state is saved at every movement, a checkpoint, and the run resumes exactly where it stopped. For workflows that involve humans or run for hours, this is not a luxury; it’s the whole feature.
- Two runs, same path. The improvising supervisor might call the researchers once, twice, or skip one. The score plays the same movements every time. When something goes wrong, you know exactly which movement to blame, and your evals test each movement separately.
- Each chair has its own budget and its own rights. The triage movement runs a small cheap model; only the writer gets the big one. The researchers get read-only tools; only the publish movement can send anything, and it sits behind the fermata. Guardrails in the structure, not in the prompt.
- Fewer conducting decisions, smaller bill. Every “who plays next?” decision the supervisor used to make was a model call. The score answers most of them for free, in code. Yesterday’s 15× multi-agent overhead doesn’t vanish, but the conducting share of it does shrink.
This is exactly what the current tools ship: LangGraph’s graphs with checkpointing, Microsoft Agent Framework’s workflows, Claude Code’s workflow scripts orchestrating subagents. Same idea everywhere: agents in the nodes, code on the edges.
The word of honesty
- Don’t write a score for a jam. Exploratory work (debugging something unknown, open-ended research) can’t be scored in advance; you’d be notating music nobody has heard yet. Keep the free agent, or the improvising supervisor, for genuinely unpredictable tasks.
- Hybrid is normal, not cheating. The most common production shape is a score whose movements contain improvisers: the graph fixes the big sequence (research, then write, then review, then sign-off), and inside each movement an agent improvises freely. Structure between, freedom within.
- The classic trap: the forty-movement symphony. If your graph needs a legend to be read, you’ve over-engineered it. Start with three movements and one repeat sign; add the next movement the day a real failure asks for it.
The recap table
| The score | The graph | What it gives you |
|---|---|---|
| A movement | Node containing a full agent | Focused work, own context and tools |
| Order of movements | Edge | The fixed sequence, free of charge |
| Alternate ending | Conditional edge | Choice only where you marked it |
| Repeat sign, capped | Loop with max retries | Second chances, never infinite |
| Tutti + everyone ready | Parallel fan-out + barrier | Speed on decomposable work |
| Fermata | Human-in-the-loop gate | The pause that waits for a human cue |
| Annotated shared score | State + checkpoints | Audit trail, and resume at bar 42 |
In a nutshell
Graph-driven agent orchestration is yesterday’s orchestra playing from a written score: whole agents in the nodes, code on the edges, choices only at the marked junctions, and a saved state that lets a long concert resume where it stopped. Jam session for the unknown, symphony for the repeatable, and most real systems humming somewhere in between: a firm score, improvised solos.
If you can follow a score, or a metro map, you can read an orchestration graph. Really: it’s not rocket science.
A word you don’t know? The glossary defines every AI term, in plain language.
