AI-Native Series · Control for Agentic Systems
The Critical Path
1-minute takeaway — what you'll walk away with
The graph layer is the newest thing here, and saying so is not a dismissal — it is a prediction about where the open problems are. PERT's critical path (1958) transfers directly and is almost never used: if your slowest reviewer sets wall-clock, optimising anything else buys nothing. The sharper finding is structural: a DAG is acyclic by definition, a repair loop is a cycle, so every framework quietly picks one of three workarounds — bounded unrolling, hiding the loop inside a node, or abandoning termination guarantees. Hidden loops keep all of Episode 3's oscillation behaviour while being invisible to the orchestrator meant to govern them. The season closes with the one bet I would actually place.
Cold open
1958. The US Navy is building the Polaris missile system: thousands of tasks, hundreds of contractors, and a schedule nobody can hold in their head. The technique invented to survive it — PERT, with CPM arriving alongside it in 1959 — does something a task list cannot. It draws the tasks as a network of dependencies and then computes the one chain that determines the finish date.
The critical path. Not the longest task. The longest chain. Shorten anything off it and the project finishes on exactly the same day.
That is the graph layer's founding insight, and here is the uncomfortable fact this episode is built on: it is the youngest prior art in this entire season.
The age asymmetry
Line them up by birthday:
| Layer | Canonical prior art | Born | Age in 2026 |
|---|---|---|---|
| Loop — mechanism | Watt's centrifugal governor | 1788 | 238 |
| Loop — theory | Maxwell, On Governors | 1868 | 158 |
| Loop — decision procedure | Routh / Hurwitz | 1877 / 1895 | 149 / 131 |
| Loop — engineering margins | Nyquist | 1932 | 94 |
| Loop — as audited practice | Shewhart / PDCA → ISO 9001 | 1939 | 87 |
| Graph — precedence networks | PERT / CPM (CPM developed 1956–57) | 1958 / 1959 | 68 / 67 |
| Graph — concurrency semantics | Petri nets | 1962 | 64 |
[EVIDENCE] The loop's mathematics is ninety years older than the graph's: Maxwell 1868 to PERT
1958. Anchored on the criterion rather than the theory it is eighty-one years — Routh 1877 to 1958 — and this episode uses whichever anchor it names, rather than the larger number everywhere.
[DESIGN] A caveat on my own filter, because it flattered the thesis: when I ran this question through a 300-year survival screen with a 75-year floor, the graph layer's designs "did not qualify." That is arithmetic, not a finding — 2026 − 75 = 1951, so PERT, CPM and Petri nets are excluded by construction. The age table above makes the point honestly; the filter result adds nothing.
[DESIGN] That is not an argument that graph engineering is unserious. It is an argument about what you should expect: the loop layer has settled answers you can look up, and the graph layer is still genuinely being worked out. Which matches the research: From Static Templates to Dynamic Runtime Graphs: A Survey of Workflow Optimization for LLM Agents (arXiv:2603.22386) treats agent workflows as agentic computation graphs and surveys how to design and optimise them — a survey of an open problem, not a settled discipline.
The shape that cannot say what you need
[DEF] A DAG — directed acyclic graph — is the default shape for orchestration: Airflow, build systems, CI pipelines, most agent frameworks. Acyclic is the whole point. It guarantees termination and gives you a topological order.
[DERIVATION] And that guarantee is exactly the limitation. A DAG cannot express a cycle. But the thing Episode 3 spent its entire length on — read the plate, adjust, send another slip — is a cycle. So the moment your planner → implementer → reviewer pipeline needs to route a failed review back into a repair loop, you are outside what a DAG can represent, and you do one of three things: unroll the loop to a fixed depth, hide the loop inside a single node (and lose all visibility into it), or leave the DAG (and lose termination guarantees). Whether bounded unrolling caps achievable quality at the unroll depth is the Research Challenge below, and it is [OPEN] — I assert it as a hypothesis, not a derivation.
Petri nets (1962) handle concurrency and cycles honestly, which is why they survive in protocol and workflow verification while being almost absent from agent frameworks. [OPEN] Why the agentic tooling reached for DAGs rather than the formalism that actually models its dynamics is, I think, a tooling-inheritance accident rather than a considered choice — Airflow was there, Petri nets were in a textbook.
[DEF] What makes prompts a graph: necessary and sufficient conditions for prompt graph engineering (arXiv:2607.27578, Jul 30 2026) — a solo-authored conceptual analysis, not an empirical result — is the closest thing to a formal treatment: it represents prompt-mediated computation as executable graphs with nodes, data and control edges, state, branching, parallelism — and cycles. Note the date. The formalisation of the graph layer is weeks old, which is a fair statement of where this layer actually is.
1:1 technical map
| Polaris, 1958 | Graph engineering | The agentic version |
|---|---|---|
| Task | node | planner / implementer / reviewer agent |
| Dependency arrow | control edge | handoff |
| Shared blueprint | shared state | the session or scratchpad |
| Critical path | longest dependency chain | the chain that sets wall-clock, usually unmeasured |
| Slack on a non-critical task | slack | the parallel review nobody waits for |
| Milestone sign-off | termination condition | "when is this workflow done?" |
| — | cycle | the repair loop a DAG cannot draw |
[DESIGN] The critical-path idea transfers directly and is almost never used. If your workflow runs a security review in parallel with a test agent and the security review takes four minutes to the test agent's forty seconds, then security review is your critical path and optimising the test agent is free of any effect on latency. That is a 67-year-old technique and it is sitting unused in most agent orchestration.
Prediction Gate
Commit before reading on.
A team parallelises a five-agent review workflow. Sequential wall-clock was 6 minutes. They run all five concurrently and measure 5 minutes 40 seconds.
Bet: where did the parallelism go?
Almost certainly into one long chain that was never parallel to begin with — plus a shared-state write that serialises the finish. Amdahl's argument in project-schedule clothing: parallelising off-critical-path work buys nothing, and CPM's whole contribution in 1959 was telling you which work that is before you spend a sprint on it.
Failure Room
Break it deliberately: give the graph a cycle it is not allowed to have.
Build a planner → implement → test → review DAG. Now require that a failed review re-enters implement. Watch what your framework does. In most, one of three things happens: it refuses (honest); it silently unrolls to a fixed retry count (a cap masquerading as a loop); or it deadlocks on shared state because two nodes now write the same key at unpredictable times.
Diagnosis: the failure is not in your code, it is in the choice of formalism. You expressed a cyclic control problem in an acyclic language and the compiler of last resort — production — found out. And notice the compounding: the loop you smuggled inside a node still has all of Episode 3's gain and dead-time behaviour, except now it is invisible to the orchestrator.
Lab — 15 minutes
Compute the two numbers your orchestrator does not print.
- Take one multi-step agent workflow. Log start and end timestamps per node, plus edges.
- Compute the critical path: the longest chain by summed duration. Compare it to total wall-clock. The gap is your real parallelism, and it is usually smaller than the graph suggests.
- Now find every cycle you have smuggled in — any node whose internals retry, re-judge, or repair. For each, record its iteration count.
- Report: critical path, wall-clock, and the longest hidden loop. If a hidden loop's duration exceeds your critical path, your graph diagram is describing a minority of your runtime.
Reality Mission
Draw your actual orchestration on one page and mark every cycle in red — including the ones hiding inside a single node as a retry, a re-judge, or a repair. Then ask which of those red marks your orchestrator can see. Every unseen cycle is a governor with no gauge, and Episode 3 is about what happens next.
Research Challenge
Point an agent at the formalism gap. Take one real agent workflow with at least one repair cycle and express it twice: once as a DAG with bounded unrolling, once with explicit cycle semantics following arXiv:2607.27578. Compare termination behaviour, observability of the repair loop, and total cost at matched quality. The claim to test: bounded unrolling caps achievable quality at the unroll depth, and the cap is invisible in the metrics — it looks like a plateau, not a ceiling. [OPEN]
Exit test
- What does the critical path tell you that a task list cannot? (which work, if shortened, changes the finish date — and by implication, which work is free to optimise and pointless to)
- Why can a DAG not express a repair loop, and what are the three usual workarounds?
- Which is older: the loop's stability criterion or the graph's precedence network? By how much? (the loop's, by ~80 years — Routh 1877 vs PERT 1958)
Cliffhanger — and the season's answer
So: are these four labels real?
Prompt engineering is mature and surveyed. Harness engineering and loop engineering are two views of one object — the vendor definition says so outright (Episode 2). Graph engineering is the newest, with its formalisation dated weeks ago, and it inherited a shape that cannot express its own core dynamic.
The skeptics who call this rebranding are right about the topology and wrong about the stakes. The topology is 238 years old. What is new is that the plant is stochastic and the actuator argues back — and that makes the old analysis more necessary, not less. We imported the diagrams and left the mathematics.
The one thing I would put money on: the next real advance in this vocabulary is not a fifth "engineering." It is somebody publishing the agentic equivalent of Routh's 1877 criterion — a decidable test for whether a given agent loop is stable.
I nearly justified that bet with a tidy line about each layer getting its theory "about a decade" after people started building the thing — and this season's own table refutes it by a factor of eight. Watt shipped in 1788; Maxwell explained it in 1868. Eighty years. What is defensible is that the interval is collapsing: the loop waited eighty years for its Maxwell, the graph waited four for its Petri, and prompting got its surveys inside three. On that trend the agentic criterion is close. On the loop's own precedent it is due in the 2090s.
I think it is close. I am telling you which number would make me wrong.
→ Back to the Season 6 overview · Season 7 candidate: The Instrument Engine — what you must measure before any of this is engineering.
Read next
Episode 4 of Intelligence Engineering Adventures, Season 6 — The Governor Engine. Claims in the series source are tagged by class — definition, derivation, evidence, engineering choice, open question — and a metaphor may introduce a claim but never serves as evidence for it. The season takes the four-label diagram seriously enough to check it against its own primary sources, and it does not survive: Anthropic's definition makes the harness the loop rather than a layer above it. Every claim is tagged by class, and the one genuinely open problem is stated as open — nobody has published a stability criterion for an LLM control loop. This article contains no material from any employer or client. — Paul Jialiang Wu · agentic-portfolio-lovat.vercel.app
References
- PERT (1958) and CPM (1959) — precedence networks and the critical path; Petri, C.A. (1962) — nets with honest concurrency and cycle semantics.
- From Static Templates to Dynamic Runtime Graphs: A Survey of Workflow Optimization for LLM Agents — arXiv:2603.22386 (Mar 23, 2026). Agent workflows as agentic computation graphs. The brief that started this season cited this as "A Survey of Workflow Optimization for LLM Agents"; the ID is right, the title is not.
- What makes prompts a graph: necessary and sufficient conditions for prompt graph engineering — arXiv:2607.27578 (Jul 30, 2026). Nodes, data/control edges, state, branching, parallelism, cycles. Cited in the brief as "Necessary and Sufficient Conditions for Prompt Graph Engineering."
- Large Language Models for Constructing and Optimizing Machine Learning Workflows: A Survey — arXiv:2411.10478.
- Anthropic, Building Effective AI Agents — the workflow/agent distinction this episode leans on. https://www.anthropic.com/engineering/building-effective-agents
- Bouchard, L., Graph Engineering vs. Loop Engineering: What Actually Changed? — the most explicit direct comparison in the practitioner literature; informed analysis rather than peer review. https://www.louisbouchard.ai/graph-engineering-explained/