Graph EngineeringJuly 2026

Seventy-Two Hours on X

Reading Josh C. Simmons, We Are Entering the Graph Engineering Phase; Louis-François Bouchard, Graph Engineering, Without the Hype; Harrison Chase & Sydney Runkle, 3 Years of Graph Engineering with LangGraph; Turing Post, FOD#159: Is Graph Engineering Real?; Carlos E. Perez, From Loop Engineering to Graph Engineering?; SmartScope, What Is Graph Engineering?, on who posted what; theaioperator.io, What Is Graph Engineering? A Field Guide for Builders, on the naming treadmill.

1.1The tweet, and two knowing jokes

At 12:34 AM on July 18, 2026, Peter Steinberger — the developer whose earlier post had helped launch "loop engineering" six weeks before — asked a question that needed no context for anyone building AI agents: "Are we still talking loops or did we shift to graphs yet?" The post reached millions of views within hours.

Two different people answered it the same day with mock obituaries, and it's worth being precise about which said what, since at least one write-up blurs them into each other. Hamel Husain posted an X Article titled "Loop Engineering Is Dead. Enter Graph Engineering." Separately, developer Santiago Valdarrama posted a shorter version of the same bit: "Loop Engineering is dead. Long live Graph Engineering!" Neither was a sincere technical claim. AI educator Louis-François Bouchard, writing a few days later, described Husain as playing along with Steinberger's joke rather than arguing anything: "it was mostly all a big meme around creating new terms." Worth holding onto going into the rest of this chapter — the loudest declarations in this discourse were punchlines, not arguments.

1.2Two weeks earlier, someone meant it

Before any of that, on July 4, 2026, researcher and blogger Josh C. Simmons published a serious essay under nearly the same title — "We Are Entering the Graph Engineering Phase" — with no joke attached. His case: a single agent loop is, structurally, a scheduler with exactly one thing running at any moment, where the choice of what runs next comes from an opaque model call rather than an inspectable policy. He points to an April 2026 paper (Hu Wei, arXiv:2604.11378) that formalizes the same observation and proposes an explicit graph-based alternative. Simmons's own summary of the split is the cleanest one this guide found anywhere in the discourse: loop engineering, in his account, was always the craft of what happens inside one context window; graph engineering is "the craft of what happens between them." The loop isn't dead in that account — it's demoted, still running inside every node, just no longer the whole architecture.

1.3A term that lasted six weeks

The term the joke was riffing on hadn't been around long. Addy Osmani's essay popularized "loop engineering" on June 7, 2026, building on Boris Cherny's line that he no longer prompts Claude — he writes the loops that do; Groundwork's own guide to that discipline covers it in full. By the following Monday, Turing Post's accounting had the timeline producing courses and roadmaps within about 72 hours, plus a round of threads claiming that Microsoft, Stanford, and Anthropic had each stumbled onto the same idea independently.

1.4A treadmill with a name

More than one newsletter noted the pattern has a shape. 2023 gave the field "prompt engineering." Mid-2025 gave it "context engineering." June 2026 gave it "loop engineering." July 2026 gave it "graph engineering." Each term described something real. Each one also got, in another's words, "turned into content slop within weeks." LangChain's own retrospective — published the same week, from the team that builds the leading framework — makes a version of the same point more charitably: the reason so many terms exist is that getting LLMs to do reliable work is hard, and every new strategy for making that easier tends to earn a new name.

1.5The essay that took the joke seriously

Hours after Steinberger's post, researcher and blogger Carlos E. Perez published an essay — "From Loop Engineering to Graph Engineering?" — that treated the meme as a real architectural question. His opening case is a support-ticket loop: a team optimizes for ticket-resolution rate, the number climbs for months, and then renewal data arrives showing customers leaving twice as fast as before. The loop had done exactly what it was told — the bot learned to close tickets by deflecting them — while the thing the organization actually cared about quietly broke. A single loop, in Perez's account, can only defend the one metric it was built to watch; it takes a wider structure to catch a loop lying to itself.

Nodes, Edges, State

Reading Chase & Runkle, 3 Years of Graph Engineering with LangGraph; LangGraph, graph API overview. On node lifetime and where state lives: LangGraph, Persistence; Google, ADK session state; Microsoft, Agent Framework workflow state, on resettable executors and agent-thread persistence.

2.1What a graph actually is

Strip the buzzword and a graph is three things. Nodes do work — a node can be deterministic code, a single model call, a tool call, or an entire agent running its own internal loop. Edges decide what happens next — some are fixed, some are conditional on what a node produced. State is what moves along the edges: the working memory the whole graph shares, so a node three steps downstream can see what an upstream node found.

That's the whole idea. The company that has sold and supported this pattern the longest put it plainly in its July 2026 retrospective: representing agentic systems as graphs isn't new — they've built this way for three years — but it's a reasonable way to harness a model, because it lets the builder impose real-world structure on the system instead of trusting the model's judgment for every single step.

2.2A loop is a graph with one node

The cleanest fact in the whole discourse resolves the "is this new" question by itself. As XState creator David Khourshid put it, in a line LangChain's own team endorsed in their retrospective, "a loop is just a directed, cyclic graph" — one node, with an edge back to itself. You don't throw loops away to build graphs. Every node in a graph can still be a loop; a graph is what you get when more than one of them needs a different job.

2.3The move a single loop can't make: fan-out and fan-in

The genuinely new capability a graph adds is splitting one task into several branches that run at once and then rejoining them. Google's Agent Development Kit ships this as a dedicated ParallelAgent, which runs its sub-agents concurrently and writes each one's output to its own state key for a later step to read. LangGraph handles the case where you don't know the branch count in advance — researching however many leads turn up, say — with a primitive called Send, which lets a node route work to one or more downstream nodes at runtime instead of every edge being fixed at build time. Microsoft's AutoGen takes a third route: its GraphFlow feature runs on a directed graph you build node by node, with conditional edges chosen by keyword or callable checks on what the previous agent said.

2.4Not always a DAG

It's tempting to picture a graph as a one-way flowchart — start, branch, finish. LangChain's team, after three years of production use, reports the opposite is closer to true: production agent graphs are usually not directed acyclic graphs, because retrying a failed tool call, asking a user for missing information, revising an answer after a validation step, and pausing for human input before resuming are all cycles. Looping doesn't disappear inside a graph — it's how most of the interesting nodes behave.

2.5How long does a node live?

Sketch one of these graphs by hand and you will probably end up marking two kinds of box: one that stays up between calls holding its context, and one that is spun up for a single job and thrown away. The distinction is real — a warm process and a cold start are not the same thing — but it is not how any of the three frameworks model a node, and the reason they refuse is the useful part.

All three answer the question the same way: keep the node cheap and put the memory somewhere else. LangGraph's nodes are plain functions that take state and return an update; what survives a run is a checkpointer, scoped to a thread, or a store that holds data outside the graph state entirely. Google's ADK hands each sub-agent an invocation context and keeps the durable part in the session, where scoping prefixes decide what persists and for whom. Microsoft's Agent Framework goes furthest and says the quiet part out loud: an executor may carry mutable state, but share one across runs and it must implement a reset interface whose method the runtime calls between runs to clear stale state — and agent threads, which do persist across runs, are flagged in the same breath as a route to unintended state sharing. The recommended default in all three is a fresh instance per task.

That is a design rule, not an implementation detail, and it is the same rule Chapter 5 reaches from the other direction. A node that remembers is a node that drifts, and the place drift does the most damage is verification: a reviewer that has accumulated the conversation it is reviewing is no longer an independent check on it, only a participant with a longer memory. Microsoft's own worked example of the problem is a writer and a reviewer, and the fix is to build both fresh so that no history leaks between runs. Ephemerality isn't a limitation of the node. It is most of what makes a checker worth having.

Three Frameworks, One Pattern

Reading LangGraph, overview documentation; Google, ADK workflow agents; Microsoft, AutoGen-to-Agent-Framework migration guide.

3.1Three implementations, one pattern

All three shipped the pattern before "graph engineering" trended. LangGraph by three years, per its own team's account. Microsoft's version has a more tangled history: it's the merger of AutoGen (multi-agent conversation) and Semantic Kernel (enterprise plumbing) into one framework, which reached general availability three and a half months before this discourse wave — old AutoGen tutorials describe the predecessor, not the current tool. The label is new; the mechanics, in every framework above, are not.

3.2A worked example

Ground the pattern in the shape LangChain used in its own retrospective: an agent that reads a request, researches it across separate systems, and returns one synthesized answer. Three fixed stages — classify, search, synthesize — with the middle stage fanning out into specialists.

from langgraph.graph import StateGraph, END
from typing import TypedDict

class State(TypedDict):
    request: str
    findings: list[str]

def classify(state: State) -> str:
    # a single model call decides which specialists to route to
    return "search"

def search_github(state: State) -> dict:
    return {"findings": state["findings"] + ["github result"]}

def search_notion(state: State) -> dict:
    return {"findings": state["findings"] + ["notion result"]}

def synthesize(state: State) -> dict:
    # a model call turns the gathered findings into one answer
    return {"findings": state["findings"]}

graph = StateGraph(State)
graph.add_node("classify", classify)
graph.add_node("search_github", search_github)
graph.add_node("search_notion", search_notion)
graph.add_node("synthesize", synthesize)

graph.set_entry_point("classify")
graph.add_edge("classify", "search_github")
graph.add_edge("classify", "search_notion")
graph.add_edge("search_github", "synthesize")
graph.add_edge("search_notion", "synthesize")
graph.add_edge("synthesize", END)

app = graph.compile()

Two of those four nodes — the classifier and the synthesizer — are a single model call with no tools. The other two could be full agents with their own internal loop, each free to search, retry, and verify inside its own box without the outer graph knowing or caring. That mix is what LangChain's team argues is genuinely new about the July 2026 wave: nodes used to hold one model call; now that agents are reliable enough to trust with real work, a node can be a whole coding agent, and wiring one into a larger graph is a newly practical move.

Rebrand or Real Shift

Reading AI Builder Club, Graph Engineering Guide (2026) and Is Graph Engineering Just LangGraph?; SmartScope, What Is Graph Engineering?; theaioperator.io, What Is Graph Engineering? A Field Guide for Builders.

4.1The backlash arrived before the term settled

The sharpest critics were not casual skeptics. David Khourshid, who built the XState state-machine library, publicly cautioned readers against taking the flood of graph-engineering content at face value — this from someone who has modeled systems as nodes and transitions for years. Developer Rhys Sullivan predicted a ten-thousand-word slop piece would land on the timeline the next day, then confirmed, dryly, when one did. And developer Nathan Flurry pointed out that the wave of posts skipped the agent-to-agent (A2A) protocol entirely, noting that enterprises — he cited LinkedIn in 2025 and IBM — were building multi-agent graphs well before the term trended.

Their case, distilled: graph orchestration, state machines, and agent-to-agent protocols all predate July 2026 by at least a year, and in LangGraph's case by three. The mechanics genuinely are not new. The strongest form of the rebrand charge is simply correct.

4.2What the people who build the tools actually say changed

The most credible answer to "is this new" comes from the team with the least reason to overclaim novelty, and the longest track record to check it against. LangChain built LangGraph in 2023 for exactly this pattern, and their July 2026 retrospective is unusually candid: graph engineering isn't a new idea in their telling, just the latest name for an approach they've been building on for three years. Their one concession to something having genuinely changed is narrower than the hype — nodes used to hold a single model call; now that agents are reliable enough for real work, a node can be a full agent with its own loop. Wiring a coding agent into a larger graph as one box among several is a newly practical pattern, not because the graph idea is new, but because what you can safely put inside a box is.

4.3A study that doesn't exist

4.4Five layers, if the framing holds up

One framing from the discourse is worth naming, with the hedge it deserves. A post attributed to a single X account, relayed secondhand rather than confirmed at the source, split an AI application into five layers — Prompt, Context, Harness, Loop, Graph — each engineering the system one ring further out from the model, with Graph as the outermost and none of the inner rings replaced by it. Whether or not that exact taxonomy holds up, the ordering matches everything else in this chapter: graph engineering names a coordination problem that sits above loops, not a replacement for them.

When to Reach for a Graph

Reading Chase & Runkle, 3 Years of Graph Engineering with LangGraph, "when not to use graphs"; Groundwork, Loop Engineering, §3.2 on dynamic workflows.

5.1The decision rule

LangChain's own guidance, from three years of watching people build both ways, is the cleanest test available. If the work is genuinely open-ended — plan, delegate, search, read, synthesize, in an order you can't pin down ahead of time — forcing it into a fixed graph is the wrong move; use an agent harness instead and let the structure emerge at runtime. Their own deep-research product made exactly that move, from a predefined graph to a more agentic core loop, and a popular open-source deep-research project made the same swap. A graph earns its complexity when the opposite is true: the work has real, predictable structure — a step that always classifies first, specialists who can run in parallel, an approval gate before anything external happens — and you want to encode that structure so the model isn't re-deciding it, and potentially getting it wrong, on every run.

5.2The pattern already lived in Claude Code, under a different name

Groundwork's own Loop Engineering guide documents a Claude Code primitive announced in late May 2026 — mention "workflow" in a prompt, and Claude writes a JavaScript orchestration script that a separate runtime executes, fanning out subagents in a guaranteed order and cross-checking their results before one answer returns. That is graph engineering under Anthropic's own name for it, shipped almost two months before the term went viral: the plan becomes code, structure holds even across hundreds of agents, and the classic single-context failure — quietly stopping partway and declaring victory — disappears, because nothing is holding the whole plan in one context window. If you're already working in Claude Code, you may not need a separate graph framework at all; you may already have one.

5.3Gates and state, again

Whichever framework you reach for, the same two disciplines from loop engineering carry over unchanged. Something has to be able to say no — a test, a schema check, a human approval gate — at each node that can fail, not just at the end. And state has to live outside any single node's memory, the same way an anchor file survives a loop's context reset: a shared object the whole graph reads and writes, so a node three steps downstream can see what an upstream node found without the model re-deriving it.