Most people who try to build a multi-step agent end up with a straight line. Step one, step two, step three — each one waiting politely for the last to finish before it starts. Half of those steps usually never needed to wait at all.
This isn't a prompting problem. It's a shape problem. A prompt is a sentence. A loop is a cycle. But the actual shape of the work — what runs before what, what can run at the same time, what genuinely has to wait — is a graph. Nodes do the thinking. Edges carry the results.
Claude Code's dynamic workflows give you the tooling to build that shape directly. Instead of narrating steps to a model one at a time, Claude writes a plain JavaScript orchestration script and spawns a coordinated fleet of subagents to run it — and the coordination itself costs zero model tokens, because at that layer it's code, not conversation.
Below are the first two steps of the fourteen it takes to get there.
Step 1: Nodes Are Jobs, Edges Are What Flows
A graph has exactly two things in it, and getting them straight resolves most of the confusion people carry into their first attempt. A node is a unit of work: one agent, one bounded job, one input in and one output out. An edge is a dependency — a promise that this node's output feeds that node's input, nothing more.
The mistake almost everyone makes at first is treating "and then" as an edge. "Summarize this file, then tell me the weather" has no edge between the two steps — the weather doesn't consume the summary. That's two disconnected nodes that a linear script chains together for no reason. An edge only exists when data actually moves across it.
Step 2: Your Linear Script Is a Degenerate Graph
Writing an agent as "do A, then B, then C, then D" is still a graph — just a single unbranching chain where every node has exactly one edge in and one edge out. It runs correctly. It also runs slowly and breaks easily, because a chain carries no redundancy: if C stalls, D never happens, and whatever A already finished sits trapped upstream with nowhere to go.
The first real skill of graph engineering is redrawing that chain. Take a linear agent and, for every arrow in it, apply the Step 1 test. Most chains turn out to have two or three arrows that never carried data in the first place. Cut those, and the chain collapses into something wider: a handful of independent nodes that can all run at once, feeding a single node that needs all of them.
Where the Other Twelve Steps Go
From here, the roadmap covers the patterns that make graphs production-grade rather than just faster:
- A contract on every node — so Claude can wire work in without guessing what a node expects or returns.
- Fan-out with parallel() — gathering fifty independent sources at a single barrier instead of one at a time.
- The diamond topology behind almost every research or audit workflow — split, work, merge.
- Runtime routing — sending an edge down one of several paths with a deterministic conditional.
- Adversarial verifiers on the edge — so a finding has to survive skeptics before it counts.
- Worktree isolation — so one agent's writes can't collide with another's.
- Convergent loops — so a discovery cycle closes instead of running forever.
- Model tiering across nodes — so judgment gets the expensive model and repetition doesn't.
- Self-routing graphs Claude draws itself, for jobs that can't be planned by hand.
The full guide also includes six ready-to-build graphs — a security sweep, a cited research report, a file-by-file module port, adversarial diff review, a scheduled ecosystem scan, and open-ended bug discovery — plus a working code example for every core pattern.
Fourteen steps, six graphs, and the shift from writing prompts to designing systems.