Resources / Agent Engineering
Graph engineering is a loop that learned to branch.
Nodes, edges, and shared state, wired through a loop that retries and heals itself. This is how the AY framework was already running before the term had a name, walked through with real, interactive diagrams instead of another wall of prose.
Credit where it's due
We did not coin "graph engineering."
The escalation ladder framing below, prompt, context, harness, loop, graph, comes from aibuilderclub's Graph Engineering Guide, published as part of a July 2026 discussion on where agent engineering was heading next. That article also names its own prior art honestly: LangGraph, AutoGen's GraphFlow, Google's ADK, and the A2A protocol all modeled agent work as graphs long before the phrase existed.
What we bring to this page is not the term. It's a framework that has been running the graph plus loop combination in production internally since before this vocabulary existed: the AY multi-agent build system that plans, locks, builds, reviews, and merges tasks across scoped agent nodes. We're using the aibuilderclub vocabulary because it's the clearest description of a shape we already had a name for internally, and it's a better name than ours.
The escalation ladder
Each rung engineers one layer further from the raw model call. Click a rung to read what changes at it.
Graph: Nodes, edges, shared state. Specialized agents pass work along routed paths.
Nodes, edges, and shared state
A graph is three parts. Nodes do one job each. Edges route work between them, straight, conditional, fan-out, fan-in, or looped back. Shared state is the one object every node reads and writes, instead of each node keeping its own memory.
Nodes
A specialized agent or a deterministic step with exactly one job.
Edges
The route between nodes: straight, conditional, fan-out, fan-in, or a loop-back.
Shared state
The one object traveling the graph: brief, sources, draft, score, verdict.
Loop or graph?
A graph is not automatically better. It costs more tokens and more surface area to break. Reach for one only when the signal is actually there.
| Signal | Loop is enough | Reach for a graph |
|---|---|---|
| One agent, one job, retrying until a check passes | ||
| Two or more specialized roles need to hand off work | ||
| Work can branch (skip a step, retry a step, escalate) | ||
| State is a single running buffer, not shared structured data | ||
| Parts of the task are independent and can run in parallel | ||
| You need a human approval gate mid-task | ||
| The task is genuinely linear with no branching or handoff |
The AY swarm, as a graph
The cycle observes the task board, locks the task, then a planner assigns scoped worker nodes. Self-review and adversarial checks look at their output and loop back to planning on failure. A clean run gets tested, logs a learning, and unlocks. This is the actual shape of the AY framework's /go cycle.
What a graph actually costs
More nodes read the same state and a review stage re-reads the output, so a graph spends more tokens than a single loop. Parallel fan-out trades some of that extra cost for lower latency.
Illustrative, not a benchmark. A graph costs more tokens than a single loop because more agents read the same shared state and a review stage re-reads the output. Parallel fan-out spends more tokens to buy back latency: independent nodes run at the same time instead of one after another.
How production graphs actually break
Not hypothetical. These are the three failure modes the AY framework's lock and review protocol exists to catch.
State drift
Two nodes write to the same field with different assumptions about its shape. AY forces one shared tracking layer (BOARD.md, HANDOFFS.md) instead of letting each agent invent its own state format.
Node isolation gone wrong
A worker scoped to one directory reaches outside it and collides with another worker's edit. The lock file protocol (one lock per task, committed before writes) exists specifically to catch this before it merges.
Silent recovery, not real recovery
A loop-back retries the same failing step with the same input and calls it self-healing. Real recovery changes something: the prompt, the context, or the plan, and logs why in HANDOFFS.md so the next run does not repeat it.
A worked example
Researcher, writer, reviewer, with one shared state object mutating at every step. Click a node to see what it looked like right after that node ran.
Shared state after this node
{
"topic": "graph engineering",
"sources": ["aibuilderclub.com/..."],
"claims": [],
"draft": null,
"score": null
}Illustrative walkthrough, not a captured production log. The word counts and claim counts are invented to show the shape of the state object, not a measured run.
Stop Reading About Graphs. Have One Built.
Tell us the workflow. We'll tell you honestly whether a loop covers it or you need a graph, and place a forward deployed engineer to build it if you do.
Book a 30min Free Strategy Call
In this call, we'll walk through your project scope, timeline, and goals - so we can both check if we're a fit. No obligation, no slide deck, just a working session.
Don't want a call? Email walid@ayautomate.com
“The team is super fast - sometimes we had to slow them down. We managed to scale the company without investing into hiring.”
Elie Salame
COO, Adstronaut.io
We've created products featured in
Walid Boulanouar
View LinkedInConsultation
This call is for teams ready to move. If that's you, pick a time.
Recommended services
Forward Deployed Engineers
The embedded engineers who build and run agent graphs like this one inside your stack.
Multi-Agent Systems with Claude
The build-level walkthrough of wiring multiple Claude agents together.
Agent Swarms Architecture
How AY's multi-agent swarm coordinates roles, handoffs, locks, and the tracking layer.
Best Multi-Agent Frameworks
Where LangGraph, AutoGen, and the rest of the graph-shaped tooling landscape stands today.
FAQ
Graph Engineering Questions
What is graph engineering?+
Graph engineering is running an AI system as a set of specialized agent nodes connected by edges, with a shared state object that travels between them. It sits one layer above loop engineering: a loop is one agent repeating until a check passes, a graph is multiple agents handing work to each other along routed paths, including branches and loop-backs.
Who coined the term graph engineering?+
The escalation ladder framing (prompt, context, harness, loop, graph) comes from aibuilderclub's Graph Engineering Guide, published in a July 2026 discussion. AY Automate did not coin the term. This page uses it to describe a framework we were already running in production, the AY multi-agent build system, and to credit where the vocabulary came from.
Isn't a graph just LangGraph, AutoGen, or a workflow engine with new branding?+
Mostly, yes, and the aibuilderclub guide says so directly. LangGraph, AutoGen's GraphFlow, Google's ADK, and the A2A protocol all modeled agent work as graphs before the term graph engineering existed. What's newer is naming the practice and giving teams a vocabulary (nodes, edges, shared state) to reason about when a graph is worth the added complexity over a loop.
Do I need a graph, or is a loop enough?+
If one agent retrying against a single check covers the work, a loop is enough and a graph adds cost without adding value. Reach for a graph when two or more specialized roles need to hand off work, when the task branches, or when parts of it can run in parallel. The decision table on this page lays out the concrete signals.
How does the AY framework combine loops and graphs?+
The AY framework is a graph of scoped agents (planner, workers, reviewer) connected by a build loop: observe, lock, plan, build, self-review, test, learn, unlock. Shared state lives in plain tracking files (BOARD.md, HANDOFFS.md, task locks) instead of a database, and the loop-back happens when adversarial review finds an issue and sends the task back to the worker before it merges.
What actually breaks when you run an agent graph in production?+
Three things, mostly: state drift when nodes disagree on the shape of shared data, node isolation failures when a scoped agent writes outside its lane, and fake self-healing where a loop-back retries the same failing input without changing anything. All three are covered in the production failure modes section below, with the mitigation AY actually uses for each.
Want the embedded engineers who build graphs like this inside your stack? See Forward Deployed Engineers or read the architecture behind our own swarm on Agent Swarms Architecture.