We Are Entering the Graph Engineering Phase · Josh C. Simmons

← Writing<br>For the last two years, "agent" has meant one specific thing: a model in a while loop with tools. Call the model. It picks a tool. Run the tool, append the result, go around again until it finishes or falls over.

Every hard skill the industry developed in 2024 and 2025, context management, tool design, compaction, stop conditions, all of it was really one discipline: keeping that loop from embarrassing itself in production. Nobody named the discipline, because when there is only one way to build something, the way doesn't need a name. So let me name it retroactively: loop engineering.

Loop engineering worked. And because it worked, the bottleneck moved. The place it moved to is shaped like a graph.

The ceiling

The loop's limits have nothing to do with model quality. A paper from this spring (arXiv:2604.11378) finally said it in scheduler terms: an agent loop is a scheduler with a ready set of exactly one. One unit of work active at any moment, and the choice of what runs next is the output of an opaque model call. In any other corner of computing we would call that a very smart process with no operating system.

Every production agent complaint I hear traces back to that one observation.

The loop is serial, so a task that splits into ten independent subtasks, which describes most research and most large coding jobs, runs one subtask at a time anyway. The loop's entire state is a transcript, so "memory" means whatever survived compaction and "audit trail" means somebody scrolling a wall of text. Failure is all or nothing: die at step 40 of 60 and your choices are start over or perform surgery on a context window. There is no pause button, so an agent cannot take a human approval on Thursday and pick the work back up Friday without duct tape. And the moment you want a planner with three workers, or a builder with a critic checking its output, the loop has nothing to offer you. It is one process. It was always one process.

The shift already happened

Nobody held a keynote for it. LangGraph bet on graph-structured agents early and shipped 1.0 in late 2025. Microsoft collapsed AutoGen and Semantic Kernel into a single Agent Framework built around structured workflows. Durable execution engines like Temporal and Prefect are getting bolted underneath agents so a run can survive a crash, a restart, or a human who takes the weekend. Interop protocols like A2A and ACP are getting standardized, and interop only matters if agents are nodes that need edges.

The academic side landed in the same place. One survey this spring looked at 70 open-source agent projects and found 60 percent still running plain loops. The framing was not charitable. Plain loops were described as the pattern you grow out of.

So the practice converged and the vocabulary didn't. Fine. Here is the vocabulary: graph engineering.

What graph engineering actually is

Graph engineering is designing agentic systems as explicit graphs instead of implicit loops. Three commitments, none of them exotic.

Nodes are units of capability. A node can be a model running the familiar think-act-observe cycle, a plain deterministic function, a retrieval step, or a human being. A good node is boring. It does one thing, you can test it alone, and you can swap it out without touching anything else.

Edges are decisions. An edge is a typed transition that carries state from one node to the next. Some edges are deterministic: tests pass, deploy. Some are model-decided: does this ticket go to billing or to abuse. The job is knowing which is which, and defaulting to deterministic everywhere you can afford to.

State is an object with a schema, checkpointed every time you cross an edge. Not "whatever happens to be sitting in the context window right now."

Here is the part I want to be precise about, because people keep hearing this argument as "the loop is dead." The loop is not dead. It got demoted. Inside a node, a model still runs the same loop it always ran, and everything loop engineering taught us still applies in there. Loop engineering was the craft of what happens inside one context window. Graph engineering is the craft of what happens between them.

Why now

Three forces showed up at the same time.

Capability crossed a threshold. When individual steps fail, you fix prompts. When individual steps succeed and the run still fails, you fix architecture. Models got good enough that the constraint moved from "can it do a step" to "can the system coordinate a thousand steps," and coordinating a thousand steps is a graph problem.

Production pressure arrived. Enterprises deploying agents want audit trails. They want resumability, approval gates, and spend ceilings. A transcript gives you none of that. A checkpointed graph gives you all of it nearly for free, because those are properties of the structure rather than features you bolt on later.

And parallelism is the cheapest lever left. You...