Graph engineering: how to design agent graphs that hold up in production

Graph engineering is designing the execution graph an AI agent runs in: nodes, edges and the shared state that moves along them. Bigcircle already builds those controls on the agents it ships, with a check in code before a tool call leaves. A person approves an irreversible step, every run writes a trace, and an eval suite has to clear before traffic.

Key facts

Definition

Graph engineering designs the execution path an AI system is allowed to take: nodes that do work, edges that pick what runs next, and a shared state object that travels with the run.

How Bigcircle does it

On Skionis, Bigcircle draws a path from the request through a validation loop and a diagram a person approves, and measured template errors before deploy falling from around 10% to 4%.
On Solarpunk, Bigcircle keeps one loop and compares the agent's claimed completion with the state of the application, after plans completed with no person rose from roughly 55% to 80%.
On a telecom engagement, Bigcircle has the agent propose a configuration a person can diff, and nothing is deployed without explicit sign-off.

Comparison

A loop lets the agent pick the next step under a cap and a check, while a graph declares the valid paths and leaves the model free only inside the nodes.

Key number

On Skionis, template errors before deploy fell from around 10% to 4% once the validation loop checked each template against the live account.

The older meaning of the phrase is a drawing of a machine on paper, the kind a mechanical engineer used to dimension a part. This guide answers in the AI-agent sense, which organic results use as of 3 November 2026. A generated overview still shows the paper, so the first sentence has to name the agent meaning.

We do not ship a product named graph engineering, since we already draw a path when the stages are known. We leave a loop when the next step depends on the last result, which is the case we hit on Solarpunk. The graph is a recommendation we make when the work has a shape we can copy.

On Skionis, the DevOps agent we shipped on a live AWS account, a request becomes a spec, a validation loop, a diagram a person approves, and an apply. On Solarpunk, the desktop agent we built for executive operations, a critic decides after each step whether to continue, retry or escalate.

This guide covers what the graph is, how it sits above loop engineering, and when the extra structure is worth the cost. It then covers how to design one that holds up, and what the word does not mean. A context graph and GraphRAG model data, while this models execution, so those two pages stay on retrieval.

What is graph engineering?

Treat a graph as the path the work is allowed to take. A node does one job: code, a model call, a tool call, or a whole agent with its own loop. An edge picks the next step, and state is the object that travels with the run, which is the whole design.

A small support flow is enough to see the shape, from classify through retrieve and draft to review and approve. Code classifies the ticket, a tool retrieves the matching policy, and a model drafts a reply. A reviewer agent scores that draft, and a person approves anything that would send it, which is a gate rather than a line in a prompt.

The first three edges are fixed, and the review edge is the conditional one: ship, or loop back to draft. The figure puts that graph next to a single loop, which is one node with an edge back to itself. The graph is several nodes, some of them loops of their own, with the path drawn in advance.

A node can be deterministic code, a single model call, a tool call, or a whole agent with its own loop. Early graphs wrapped one model call per box, and that last option is the useful change. A coding agent that can finish a bounded task is now stable enough to sit as one node inside a larger path, which is multi-agent orchestration with the hand-offs written down.

LangGraph's StateGraph, read on 3 November 2026, is this same triple: a shared state object, nodes that update it, and edges that pick the next node. Google's Agent Development Kit ships sequential, parallel and loop workflow agents for the same jobs. Microsoft's AutoGen is archived as of that date, and its successor, Agent Framework, keeps graph-shaped workflows with branches, fan-out and a pause for a person.

The name is new and the shape is not, so we treat the products as implementations rather than as the definition.

Loop engineering vs graph engineering

Shann Holmberg, relayed by AI Builder Club, put the split as who decides the path, the agent or you. On Solarpunk the critic picks continue, retry or escalate after each step, so the agent chooses the next move under a cap. On Skionis we already wrote the path: spec, validate, diagram, apply, and the model works inside generation.

We already treat a loop as the simplest graph. Our loop engineering table puts graph engineering one layer out: a fixed set of steps and branches known in advance. The glossary entry cites Pavan Belagatti setting the two against each other: loops for open-ended work, graphs for steps you can write down.

Neither replaces the other, because each node still has to be a loop that can stop. Skionis keeps the validation loop on the spec, and Solarpunk keeps a critic on every step. A node that cannot stop will fail the same way whether it sits alone or on a path.

	Loop engineering	Graph engineering
Who decides the path	The agent, inside a cap and a check	You, except inside the nodes you leave open
Shape of the work	One job; the next step depends on the last result	Known stages, branches, parallel work, or different tools per step
Failure isolation	A failed check retries the same cycle	A failed node retries from the last approved state
Audit	One trace for the run	A trace per node, plus the edges taken
Cost	Tokens until the run cap	Tokens across every running node; a flaky reviewer can spend the writer's budget

Keep the loop when you cannot list the stages. Our guide on agentic workflows and AI agents is the same call: write the steps down when a person can write them, and give the model the next-step choice only when that choice is real. A graph is how you write those steps once they include a model, a tool, a person and a branch.

When graph engineering is worth it (and when a loop is enough)

Reach for a graph when you can name the stages before the run starts. Known stages, an approval, work that should fan out and join, or a different tool or model per step are the triggers. One trigger is enough, and you do not need all four.

Skip the graph when the work is one job with a check you can write. A loop with a cap and a read of the system it changed will finish that job, and adding boxes so the architecture looks complete leaves extra hops you then have to trace. We keep Solarpunk as one agent for that reason.

It reaches more than 100 tools, and each step queries a registry for the few contracts it needs, because the next system depends on the last result. A graph would have split tools the agent has to discover as it goes, which is the failure we already fixed by searching the registry.

Use a graph when a person already walks a sequence you can copy. On Skionis the sequence is spec, validate, diagram, apply, and most errors die in the validation loop before AWS is asked to start anything. An engineer still approves the diagram, because raw template diffs are not read carefully at the tenth change of the week.

That is a graph, whether or not anyone called it one while we built it. The path was what the reviewer saw, not a framework we bought.

Use a graph when two specialties would bury each other in one context. A researcher that fans out across sources, a writer that drafts, and a reviewer that only reads will each do better work than one agent told to do all three. Our multi-agent systems guide is the test for the fan-out: the slices have to return without reading each other, or the merge has to guess at an agreement they never reached.

Use a graph when an irreversible step needs a person on a node, not a sentence in a prompt. On a current engagement for a telecom marketing platform, the agent proposes a structured configuration a person can diff, and nothing is deployed without explicit sign-off. The approval is an edge that does not fire until that person returns.

Skip it for generic deep research and other work whose next hop you cannot name. LangChain moved its own early research graphs onto an agentic core loop for that reason, and GPT Researcher made the same move. Forcing those jobs into fixed boxes makes the path look tidy and the research worse.

How to design an agent graph for production

Name a node only when the stage already exists in the work. On Skionis that is spec, validate, diagram and apply. We kept Solarpunk as one agent because the next tool depends on the last result, not because the architecture looked incomplete.

Write the path the reviewer will see before you write a node. On Skionis the path is spec, validate, diagram and apply, with one loop-back in validation. Most errors die there, before AWS is asked to start anything. Plan-and-execute is the same shape: two nodes and a loop back, which is enough to start.

Treat the shared record as a contract: which fields exist, who may write each one, and what a missing field means. On Skionis we keep one record from the request through every validation failure to the resources that now exist, because an untagged change is archaeology six months on.

Give the graph the same record, since a node that cannot write the field it just decided has not finished its job.

Put a check in code on the edge before a tool call leaves, because a rule the model reads is a rule the model can reason its way past. On Skionis the agent reaches AWS only through purpose-built tools, with no general shell, and nothing in the system depends on the model being correct. On the insurance voice agent we built, permission checks and required disclosures live in the tool contract, so a failing request escalates instead of degrading into something close.

The graph inherits that stance, and the edge does not fire if the check fails.

Put a person on the irreversible node rather than in the prompt. On Skionis an engineer approves an architecture diagram before anything applies, and on the telecom engagement, deploying a campaign sits behind the same kind of gate. Human in the loop for AI agents covers what that approver should see. A graph that asks the model whether to send the refund has not added a gate, and it has added a prompt.

Checkpoint the state so a failed or paused run resumes. LangGraph's checkpointer, read on 3 November 2026, writes a snapshot of the graph state so an interrupt can wait for a person and a crash can continue from the last good node. On the telecom engagement we keep state, retries and checkpoints so a failure is resumable rather than a restart.

A graph that starts over after an approval has wasted the work the person already judged, so resume from the node they signed.

Bound every cycle with a run cap you can measure. A loop-back from review to draft without a counter will spend the budget on a draft that will not come clean, and we bound Skionis revisions and Solarpunk retries for the same reason. An agent that retries indefinitely against a broken vendor is worse than one that stops, because it burns cost and time while looking busy.

Give the loop-back its own counter, separate from the rest of the graph, so a flaky reviewer cannot spend the attempts meant for the writer. A shared counter hides which node spent the budget.

Trace every node, then score the nodes and the path. AI agent monitoring still watches latency, refusals, tool errors and whether the claimed completion matches the system the agent changed. The graph adds the edge that was taken, which is the field that tells you a run skipped approve.

Build the eval suite from real traffic, with the order in how to build LLM evals, and run it per node and end to end. A change that helps the writer and breaks the reviewer will look fine if you only score the last node.

What graph engineering is not

Keep the word graph for execution, not for the store. A knowledge graph, a context graph and GraphRAG model entities, links and the passages an agent reads. They answer what is true, who may see it, and which hop to walk, while graph engineering answers which step runs next.

Using one store for both jobs mixes a fact the business already holds with a path you invented this week, and a later reader cannot tell them apart. Leave the facts on the context graph you already have.

Directed graphs, state machines and workflow engines already ran this shape, so the phrase does not name a new capability. Runkle and Chase, writing for LangChain on 22 July 2026, named the useful change: a node can now be a full agent run rather than one model call. On Skionis the validation loop is already that kind of node: a full cycle that has to come clean before the next edge fires.

Most agent jobs still do not need the extra path. One job with one check is a loop. Skionis is a path because a request has to become a spec, pass the validation loop and clear an engineer's diagram review before anything applies. Adding boxes before that sequence exists leaves extra hops you then have to trace.

Build the loop until it can stop, which is the argument of our loop engineering guide. Split the work only when a stage, an approval, a fan-out or a different tool per step already shows up. Skionis has fixed stages and an approval; on Solarpunk the next tool depends on the last result.

How Bigcircle builds agent graphs

We draw the path when the stages are known, and we leave a loop when they are not. We do not ship a named graph product. We build the path inside the system the agent already uses, through agent orchestration when several specialists have to hand off, and through harness engineering for the state, the permissions and the trace around each node.

On Skionis the path is the request, the account read, the validation loop, the diagram and the apply. We measured template errors before deploy falling from around 10% to 4% once that loop checked each template against the live account. The model sits inside generation, and the edges around it are code.

On Solarpunk we kept one loop on purpose. Plans completed with no person rose from roughly 55% to 80% once local retrieval and planner memory grounded the agent in the user's workspace, and a critic still decides continue, retry or escalate after every step. We compare the agent's claimed completion with the state of the target application before a run counts as finished.

That comparison is the check a graph reviewer node has to pass as well. A node that reports done from its own transcript has failed the same way a loop does.

On the telecom engagement the agent proposes, a person diffs, and nothing goes live without sign-off. Each agent is scoped to the entitlements of the person it acts for, and prompts stay a user-experience layer that no policy check depends on. The graph inherits that scope rather than replacing it.

On the trademark drafting platform, every draft passes a legal-integrity harness before an attorney sees it, and the attorney stays the legal authority. The stages have a defined failure behaviour rather than a fallback to unconstrained generation. That is the same rule we apply to a node: a hop that will not come clean does not become a write.

Give each node tools that match its job, not the whole registry. Solarpunk queries a handful of contracts per step after tool selection went wrong past roughly 30 tools held in context, and Skionis wraps provider APIs and has no general shell. The graph does not change that constraint on the tools. It decides which of those already-narrow agents runs, and what state it is allowed to write.

Common questions

What is graph engineering in AI?#

Graph engineering in AI is designing the execution graph a system runs in: nodes, edges and the shared state that moves along them. The builder fixes the paths that must be predictable and leaves the model free only inside the nodes where judgment helps. A loop is the simplest such graph, one node with an edge back to itself, which David Khourshid framed as a directed cyclic graph.

Is graph engineering just LangGraph?#

The shape is the one LangGraph, Google's Agent Development Kit and Microsoft Agent Framework already ship: a shared state object, nodes that update it, and edges that pick the next node. The name is newer than those products by a few years. Bigcircle builds the same controls, a check in code before a tool call, a person on an irreversible step, a trace, and an eval gate, whether or not the runtime is one of those frameworks.

What is an agent graph?#

An agent graph is a set of nodes, edges and shared state that an AI system runs in. A node can be code, a model call, a tool call or a whole agent, and an edge can be fixed, conditional, a fan-out, a join or a loop-back. People also say agentic graph for the same design, and the agentic part is the loop inside a node, not the store the graph sits on.

What is a state graph?#

A state graph is an agent graph whose shared object is explicit: every node reads it, some nodes write it, and the edges decide the next node from that object. LangGraph names its main class StateGraph, which is this pattern. The useful work is the contract on the object, which fields exist, who may write them, and what a missing field means, not the class name.

What does a graph engineer do?#

A graph engineer decides which nodes exist, which edges join them, what the shared state holds and who may write it. They put checks in code on the edges that call tools, put a person on irreversible nodes, checkpoint so a failed run resumes, cap every cycle, and score each node and the whole path before traffic. The job is the path, not a new model.

What are the key differences between graph engineering and loop engineering?#

Loop engineering designs the checks, caps, triggers and traces around one agent's cycle. Graph engineering designs the path those cycles take once the stages are known: which node runs, what it may write, and which edge fires next. In a loop the agent picks the path, while in a graph you declare the valid paths and leave the model free inside the nodes. A loop is the simplest graph, and most tasks should stay one.