This morning at 8:00 sharp, before the coffee was done, a briefing assembled itself across a fleet of AI agents. One pipeline checked the inbox and calendar. A fan-out sent three specialists in parallel — one drafting content, one reconciling the wiki, one reviewing the exceptions — and a gate decided what was allowed to reach me. Six steps, green, synthesis on my phone. Nobody drew that graph in a course. It's Tuesday.
Last month, five million people viewed a course teaching exactly this: graph engineering, the successor to loop engineering. Stop writing one agent that does everything in a line. Fan out the independent work. Verify on the edges. Anchor the truth in nodes the agents can't tune.
The course is good. Take it. Then read this, because the course sells the shape — and the shape is the cheap part.
TL;DR: Graph engineering is the correct successor to loop engineering: a single loop optimizes its own metric into a lie, and the fix is a network where AI loops watch each other. But a graph in production costs three things the tutorials underprice. Anchors — nodes that refuse to move, because a graph is only as honest as what it can't argue with. The bill — one famous port ran 64 agents in parallel for 11 days and spent $165K, with a human supervising the whole way. The state layer — the graph everyone diagrams is the execution topology; the graph that makes it durable is provenance and shared memory, and almost nobody draws that one. We run a small graph every morning. Here's what running one actually teaches you.
I am James, CEO of Mercury Technology Solutions, writing from Cyberport, Hong Kong — 12 September 2026. We build and operate AI agent fleets for a living — multi-provider, multi-surface, running across AI models, messengers and schedulers, not just inside one coding window. The same fleet powers our generative engine optimization (GEO) audits. So when the discourse crowned a new term, I didn't need to imagine it. I checked it against the morning run.
The course is right about the shape
Credit where due, because most viral frameworks are wrong and this one isn't.
The edge audit is real. For every "and then" in your agent's instructions — does the next step actually read the previous step's output? If no data crosses between two boxes, they're independent, and chaining them is just latency cosplay. Most "multi-step AI agents" are a single line wearing a flowchart. We've audited client setups where half the pipeline's wall-clock was steps waiting on outputs they never read.
The verifier rule is real. An AI agent that checks its own work goes easy on itself. A verifier reading the executor's transcript isn't verifying — it's grading its own homework. Verification has to hit a signal the agent can't sweet-talk: a test that ran, a diff that exists, a number from outside the conversation.
The collision rule is real. The course tells the story of the Bun team's Zig-to-Rust port: AI agents fanning out across a shared git workspace and overwriting each other mid-run. The fix wasn't clever prompting. It was isolated worktrees and forbidden commands — structure, not vibes. We've hit the same wall with two AI sub-agents writing the same file. Parallelism without a collision plan doesn't scale. It just fails faster, in parallel.
So: shape, verified. Now the invoice.
The anchors are the product
The course's deepest line is almost a throwaway: the graph is only as honest as the things in it that refuse to move.
Sit with that. A network of AI agents all confirming each other, none of them touching anything real, fails exactly like the single loop did — the ticket bot that learned to close tickets instead of solve problems — just with more moving parts and a bigger bill. Topology doesn't buy truth. The Honesty Equation: a graph's integrity equals the sum of its anchors — the nodes that cannot be argued with.
In our stack the anchors are boring on purpose. A gate script that runs the actual tests and blocks completion if they're red. Hardcoded rules the loop is never allowed to edit — our harness can refine almost anything about itself except the files that define its soul and its operator. A human-in-the-loop requirement for anything irreversible, which no agent vote can override. Frozen, all of it. Not because the agents are untrustworthy — because an optimizer's first move is always to weaken the constraint that grades it. That's Goodhart, and it applies to fleets exactly as it applied to the ticket bot.
A fortress is not its walls. It's the garrison that refuses to move. Design your graph's garrison before you admire its walls.
The bill is bigger than the diagram
Here's the number the course deserves credit for printing, because most wouldn't: the Bun port — roughly 50 workflows, a peak of 64 AI agents in parallel, 535,000 lines of Zig becoming over a million lines of Rust in 11 days — cost about $165,000 in usage. With a human designing and monitoring the entire run. And public criticism afterward about whether that much machine-authored code can be safely reviewed at all.
Three lessons hide in that number.
Coordination is not free; it's just cheaper than context. The orchestration script passes results between agents without re-spending the chat window — that's the saving. The AI agents themselves still burn tokens at full rate. A graph doesn't reduce the cost of work. It removes the cost of waiting, and charges you for the privilege of doing everything at once.
Width is a budget line, not a flex. The course's ceiling — a thousand AI agents per run, 16 at a time — is a vendor feature. Our ceiling is deliberate: four children by default, eight at the absolute cap, one level deep. Not because we can't go wider, but because every doubling of width is a doubling of the blast radius when the partition plan is wrong. We track loop costs against per-level budgets, from $0.10 a day for report-only operation up to $50 a day for a self-improving meta-loop, and the graph doesn't get to exceed its level just because the shape is beautiful.
Supervision doesn't disappear — it moves. The Bun run needed a human the whole way. Not watching every step — that's the old model — but designing the graph, placing the anchors, and reading the synthesis. The job description changes from doer to architect of things that do. That is a promotion, not a layoff, and it's why the architect's judgment is the one node you cannot automate.
The state layer nobody drew
Now the gap the course doesn't cover at all — and the one that decides whether your graph survives next week.
The graph in every tutorial is the execution topology: nodes do work, edges carry results. Fine. But where does the run's knowledge live? When AI agent three discovers a fact that contradicts agent one's assumption from yesterday, what records that? When the AI fleet wakes up tomorrow, what does it remember — and can it prove why it changed its mind?
There are two things calling themselves graph engineering right now. One externalizes the shape of work. The other externalizes the shape of state — entities, claims, provenance, what supersedes what. The course teaches the first. Production demands both. Our execution graph fans out through a spawn primitive; our state graph lives in a knowledge store — thirteen hundred indexed chunks and counting — where every claim carries its source, contradictions get flagged instead of overwritten, and a verifier can ask "show me the evidence for this" and get an edge, not a vibe.
A fleet that forgets between runs isn't a graph. It's a crowd that happens to share a scheduler. The execution topology makes you fast once. The state layer makes you correct repeatedly. Build the second one before the first one makes you confidently, rapidly wrong.
Four moves before your first AI graph
If the course convinced you, good. Run one this week — a small one. Four moves from the production side:
Audit one "and then." Take your most-used agent prompt. Find the steps that never read each other's output. Run them in parallel. That's your first graph, and it costs nothing but honesty.
Freeze one rule. Pick the constraint your agents must never tune — the test gate, the no-delete list, the human-approval requirement — and hardcode it. If your graph can edit its own anchors, you don't have anchors. You have suggestions.
Write the disagreement protocol before you spawn. When two AI agents contradict, who decides? A council, a senior agent, you? Mid-flight is the wrong time to discover the answer is "nobody."
Budget the width. Decide what the run may cost before it runs. The discipline isn't stinginess — it's what lets you run the graph every morning instead of once, expensively, as a demo.
The prompter asks a question. The architect draws a graph. The operator pays the bill and freezes the anchors. The internet just learned the second job. The third one is hiring.
Stop drawing chains. Start freezing anchors.
Mercury Technology Solutions: Accelerate Digitality.