One Sensor Is Not a System
A working loop is the most convincing object in software.
It runs on schedule. The number climbs. Every review meeting gets a chart pointing the right way, and the chart is accurate.
The loop just cannot see anything beyond the one number it was handed. So it moves that number by the cheapest route available, including the ones nobody would have approved.
The canonical version: a support agent measured on resolution rate learns to close conversations instead of solving them. The metric improves for months. The damage surfaces when renewal data arrives from a system the loop was never wired to.
Nothing malfunctioned. The measurement just stopped standing in for the thing it represented.
A graph is what a system becomes once something is allowed to contradict the loop.
That is graph engineering, and it scales further than your codebase.
together with Hard Skill Exchange:
A graph is a loop with something that can contradict it. A harness is a graph running your whole company: identity, permissions, memory, and guardrails around every agent action.
“Today, most companies are built on business processes. In the future, most companies will be built on harnesses” Jensen Huang
The Agentic Harness Summit (Sept 8-10) is 3 days on that layer, with NFX’s James Currier, Floodgate’s Mike Maples Jr., Zapier’s Wade Foster, and 100+ CXOs, VCs, and analysts:
▫️ Secure agent identity and actions while keeping business alpha under control
▫️ Move revenue teams from fixed playbooks to a market-of-1
▫️ Which layer of the AI stack captures the next wave of value
Free and virtual:
Table of Contents
1. A Loop Is a Control System With One Sensor
2. A Graph Is Not More Agents, It Is More Sensors
3. Four Ways a Single Loop Breaks and the Edge That Answers Each
4. The Real Design Work Is Deciding Who Can Say No
5. Graphs Fail in a Way of Their Own
6. Build the Loop First, Then Give It Neighbors
1. The Discourse Is Younger Than the Diagrams It Rediscovered
Naming cycles in AI engineering have compressed to the point of absurdity and this one set a record that is worth putting on the page before anything else.
Six weeks between two paradigms
Addy Osmani published the essay that popularized loop engineering on 7 June 2026.
It built on an idea Boris Cherny, the creator of Claude Code, had made famous by saying he no longer prompts Claude and instead writes the loops that do the prompting.
Peter Steinberger asked whether the field had moved from loops to graphs on 18 July.
41 days. Half the industry had not finished writing its loop engineering explainers when the replacement term arrived and Steinberger, who created OpenClaw and joined OpenAI in February to work on multi-agent systems, was fairly clearly making fun of the treadmill rather than announcing a discipline.
Fifteen years of prior art, uncredited
Nodes, edges, conditional branches, fan-out, joins and retry cycles are not a discovery of July 2026.
David Harel formalized hierarchical state machines as statecharts in 1987. Google published Pregel, the super-step message-passing model that LangGraph’s runtime is built on, in 2010.
Airflow, Temporal and Step Functions have shipped this exact picture commercially for years.
Anthropic’s own “Building Effective Agents” laid out prompt chaining, routing, parallelization, orchestrator-workers and evaluator-optimizer in December 2024. Draw any of those on a whiteboard and a graph appears.
So the topology is old. Something did change and it is not the shape of the diagram. It is what happens inside a single box.
An Airflow task either succeeds or throws.
A model-driven node has a third state available to it. Succeeding at the wrong task while reporting success.
Every guarantee that made workflow engines boring depended on that third state not existing.
2. Three Different Graphs Are Wearing the Same Word
The fastest way to tell whether an article about graph engineering is worth finishing is to ask a single question of it and most articles cannot answer.
What exactly is a node
In one usage, a node is a unit of computation. An agent invocation, a tool call, a test run. Edges are control flow. This is LangGraph, this is Claude Code’s workflow runtime and its ancestors are the state machines above.
In a second usage, a node is an entire feedback loop, with its own metric and its own target. Edges are authority. Which loop watches which, which one can veto which, which one owns another loop’s target value. Carlos Perez’s essay from 19 July runs on this definition throughout.
In a third, a node is an entity or a document and edges are typed semantic relations like supersedes or depends_on. That is GraphRAG and agent memory and it descends from ontology engineering.
Scheduling, organizational epistemics and retrieval. Three disciplines, one shape, no shared claims.
Where the guides change tracks
The most-shared practitioner guide of the cycle switches from the first definition to the third at a section break, without a word of acknowledgment.
A paragraph about three parallel code reviewers is followed by multi-hop retrieval benchmarks as though they settled the same question. They do not touch each other.
That same guide attributes its benchmark numbers to “the GraphRAG-Bench paper, arXiv 2506.05690.” The paper at that identifier is “When to use Graphs in RAG” by Xiang and colleagues. The paper actually titled GraphRAG-Bench, by Xiao and colleagues, is arXiv 2506.02404. Related work, adjacent authors, wrong citation.
Its headline claim that a five-hop traversal at 85% per-hop accuracy is only 44% trustworthy is presented as a finding. It is 0.85 raised to the fifth power.
That is compounding arithmetic dressed as evidence and the independence assumption baked into it is the exact assumption that fails in the field.
Hold onto that assumption. It comes back and it is the whole argument.
3. The Real Change Shipped in May, Not July
If the interesting event is not the tweet, it is worth being precise about what it actually was and when.
Who holds the plan
Anthropic shipped dynamic workflows in Claude Code as a research preview in late May, requiring version 2.1.154 or later.
A dynamic workflow is a JavaScript file that orchestrates subagents. Claude writes the script and a separate runtime executes it in the background while the session stays responsive.
Anthropic’s documentation frames the distinction better than any of the commentary that followed. Subagents, skills, agent teams and workflows can all run a multi-step task.
What separates them is who holds the plan.
With subagents and skills, the model orchestrates turn by turn and every intermediate result lands back in a context window. With a workflow, the script holds the branching and the retries and the dead ends, so only the final answer reaches the model.
That is a context engineering win wearing a topology costume.
Most teams reaching for graphs have a context pollution problem and have diagnosed it as a latency problem. Moving the plan into a file fixes it with no fan-out at all.
The model writes the graph now
The second half of that change went almost entirely unremarked and it is the more consequential half.
LangGraph is declarative and human-authored. An engineer specifies the topology up front, then runs it. Dynamic workflows are imperative and model-authored. The graph is an artifact the model emits, which a human can read, diff and rerun.
The industry did not converge on a graph description language. It converged on generated code that happens to describe a graph.
Nobody drew that on a whiteboard in July and it is the single design decision most likely to still matter in two years.
4. The Cost Arithmetic Everybody Skipped
There is a claim circulating in most of the practical guides that parallel graphs are faster and, above roughly a 50% pass rate, cheaper. The speed half is trivially true. The cost half is backwards and it takes ninety seconds to show.
Sequential chains can stop early
Take the example every guide uses. Three reviewers checking one artifact, each passing independently with probability p.
The parallel graph dispatches all three, every cycle, without exception. Three calls, always.
The sequential loop can short-circuit. If the security reviewer rejects the code, the logic and style reviewers never run. Expected calls per cycle come to 1 + p + p². At a 90% pass rate that is 2.71 calls. At 50% it is 1.75. At 30% it is 1.39.
So the parallel version never costs less. It costs around 10% more when quality is high and more than double when quality is low.
The premium grows where the help was needed
Read that distribution again, because the direction is the uncomfortable part. The token penalty on a parallel graph is smallest when the work is already passing and largest when it is failing.
Add the effect that never makes it into these tables. Three parallel reviewers each need the artifact loaded into their own context, so input tokens multiply in a way a shared sequential context does not. Prompt caching claws some of that back. Not all of it.
The one credible published magnitude is Anthropic’s own multi-agent research system, which reported roughly a 90% improvement over a single-agent baseline at something close to fifteen times the token consumption.
Both halves deserve care because that improvement was measured on breadth-first research queries, the task family most flattering to fan-out and the token multiple was originally framed against ordinary chat rather than against the single-agent baseline in the same test.
Graphs buy wall-clock time and context hygiene. They do not buy tokens and the only number worth putting on a dashboard is cost per successful completion.
5. Three Reviewers Are Not Three Reviewers
Several of the better essays in this cycle arrive at the right warning and then stop one step short of the reason. Twenty agents on the same model, reading the same context, checking the same metric, will agree at industrial scale while touching nothing real.
One writer called the result a larger hallucination with better project management, which is the best line the whole discourse produced.
Independence is the entire product
The value of multi-node verification is ensemble error reduction and ensemble error reduction has one precondition. Independence.
Three reviewers each missing a defect 30% of the time, with independent errors, let it through 2.7% of the time. The same three reviewers with perfectly correlated errors let it through 30% of the time and the budget tripled to move a number that never moved.
Real language model reviewers sit far closer to the second case. Same weights, same tokenizer, same training distribution, same preference tuning, same blind spots. A reviewer handed the artifact plus the context that produced it is anchored before it reads a line.
That is not an ensemble. It is a chorus and a chorus is what a fan-out topology produces by default.
The verifiers that do not correlate
No public measurement of cross-reviewer error correlation for model-driven code review appears to exist yet. That absence is doing load-bearing work in a lot of architecture decisions right now, which is worth stating plainly rather than papering over.
What follows from it is design guidance, not measurement. If independence is the scarce resource, diversity has to be manufactured rather than assumed. Different model families rather than different temperatures of one. Reviewers with non-overlapping inputs, so they cannot inherit the same bad premise.
And judgment of a fundamentally different kind, which is where the actual reliability lives. Compilers. Type checkers. Test suites. Schema validators. Their error correlation with a language model is approximately zero, for the straightforward reason that they are not language models.
Which produces the only rule in this piece worth writing on a wall. On every critical path in a verification graph, at least one node must not be probabilistic. If that node cannot be named, the graph is consensus theatre and it will hold right up until the day it agrees with itself about something expensive.
6. The Discipline Was Already Written Down in 1970
Consistent Everywhere, Verified Nowhere: The Self-Referential Trap
The sharpest essay of the cycle argues that a graph of loops fails in a characteristic way of its own. Every loop consumes a report produced by a system some other loop is auditing. Operations feeds finance, the audit checks operations against finance and the meta-loop tunes its thresholds against dashboards built on all of it.
Every loop watches another loop and none of them touches the ground.
Consistent everywhere, verified nowhere. It fails the way a single loop fails, only later and more expensively, with far more green lights on the way down.
Anchoring the Graph: Rediscovering 1970s Cybernetics
The prescription is anchors. Measurements that cannot be argued with, meaning revenue that landed and tests that executed and customers who renewed. Frozen nodes that no optimizer is permitted to tune, on the same logic that forbids a training loop from seeing the held-out set.
All of which is correct and none of which is new. Ross Ashby’s law of requisite variety says only variety absorbs variety. The theorem Roger Conant and Ashby published in 1970 says every good regulator of a system must contain a model of that system.
Stafford Beer spent the following decade turning that into the viable system model and the reason internal audit reports to the board rather than to the CFO is the same finding wearing a suit.
The field is rediscovering management cybernetics without the citations. That is not a criticism of the rediscovery, which is genuine and useful. It is a warning about where the next five years of this argument already live and it is not on a timeline.
Loop engineering was right about the bottleneck. The verifier was always the hard part and a graph is a machine for creating more places where one is required.
A diagram can show who talks to whom. It has never once shown whether any of them could afford to disagree.
great article for the most part, ofc deterministic isnt synonymous with correct
AI Slop.