What is graph engineering?
The practice of expressing what you want from an AI as a graph of nodes and connections instead of a block of prose — and compiling that graph into a specification the model can execute without guessing.
Graph engineering is the practice of expressing what you want from an AI as a graph of nodes and connections instead of a block of prose. Each node holds one idea with its own context. Each edge carries a relationship. The graph is then compiled into a specification the model can read without guessing.
What you want from a model has shape: parts, order, dependencies, exceptions. A prompt is a flat string. So you compress the shape into prose, the model tries to reconstruct it, and both steps leak. “First A, then B, unless C” was never a sentence. It's a graph, badly serialised.
Graph engineering skips the compression. The structure stays a structure, all the way to the model. And failure changes its address: instead of a model that misread your paragraph, you get a canvas that shows you the hole. An unlabelled node is a term nobody defined. A missing edge is a decision nobody made.
A node is a unit of meaning
Definition, notes, files, images, links — and, when one layer stops being enough, a whole graph folded inside.
An edge is a claim
Direction is dependency. A label is a relationship. A backward edge is a loop — and loops owe you an ending.
Position is information
Proximity, grouping, size — the layout says what sentences can't. So the layout ships with the specification.
The graph is the artefact
Not a picture of the plan. The plan — traversable, addressable, every element carrying its own name.
The layer after loop engineering
The way people work with AI has moved through distinct layers: prompt engineering optimised the wording of one message, context engineering optimised what the model sees on each call, and in 2026 loop engineering moved the human out of the prompting seat entirely — you design the system that prompts the agent, verifies its work and repeats.
Graph engineering is the layer those loops read. A loop can run without you, but it cannot generate its own ground truth: something has to define the parts, the dependencies, the criteria, the stop. That definition is the graph. One artefact, precise enough for a machine, visible enough for a human — read the loop engineering guide for the other half of the story, or see how a node carries its contract on the canvas.
Graph engineering glossary
- Graph engineering
- Expressing a task for an AI as a structured graph of context-bearing nodes and meaningful connections, rather than as prose.
- Loop engineering
- Designing the system that prompts an AI agent instead of prompting it yourself — its evaluation criteria, feedback and stop conditions.
- Node contract
- The full specification of a single node — definition, role, constraints, examples, attachments. What the node promises to the rest of the graph.
- Flow order
- The traversal order for export: topological, dependencies before dependents, layout breaking ties. Not the order the nodes were created.
- Backward edge
- A connection pointing against the main direction of flow. It turns a pipeline into a loop — the object loop engineering is about.
- Exit condition
- The rule that stops a loop: the evaluation passes, the attempt budget runs out, or a human takes over. Without one, the loop is unbounded.
- Sub-graph
- A graph nested inside a single node, so a step can be detailed without cluttering the level above it.
- Context engineering
- The practice that came before graph engineering: choosing what enters the model's context window, in what form and order.
- Handoff
- The moment the graph leaves the canvas and reaches a model — as a specification, an attachment bundle, or a live connection.
Engineer your first graph
Open the canvas. Drop a node. Give it a contract — the specification takes it from there.