These are two of the newest terms in the agentic AI world. They describe a shift in what AI developers engineer.
The progression looks something like this:
Prompt engineering → Context engineering → Loop engineering → Graph engineering
Each step moves farther away from interacting with a single LLM, and closer to designing an autonomous system.
1. Prompt engineering (2023–2024)
You write one prompt.
Human
│
Prompt
│
LLM
│
Answer
The human is responsible for every turn.
2. Loop engineering (2026)
Loop engineering asks:
How should an AI repeatedly think, act, verify, and improve until it reaches a goal?
Instead of prompting repeatedly,
Prompt
↓
Think
↓
Act
↓
Check result
↓
Need improvement?
↓
Think again
↓
...
Stop
the engineer designs the outer control loop.
Typical components include:
- goal
- memory
- tool use
- verification
- retry policy
- stopping criteria
- human approval when needed
The important shift is
You no longer prompt the model.
You engineer the process that prompts the model.
This has become central to coding agents such as Claude Code, Codex, and similar autonomous software agents.
Example
Instead of saying
“Fix this Python bug.”
you build a loop:
Read code
↓
Write fix
↓
Run tests
↓
Tests fail?
↓
Read error
↓
Write another fix
↓
Run tests
↓
...
↓
All tests pass
↓
Stop
The human may never intervene after pressing Start.
3. Graph engineering
Loop engineering works well for one agent.
Graph engineering asks a different question:
How should many specialized agents cooperate?
Instead of one loop,
you have an organization.
Planner
│
┌─────────┴─────────┐
│ │
Research Coding
│ │
└─────────┬─────────┘
│
Reviewer
│
Human check
The engineer now designs
- nodes
- edges
- routing
- shared state
- permissions
- parallel execution
- recovery
- checkpoints
rather than just one reasoning loop. Most descriptions emphasize that a graph is an explicit workflow connecting multiple loops or specialized workers.
A simple comparison
|
Loop engineering |
Graph engineering |
|
One agent |
Multiple agents |
|
One feedback loop |
Network of workflows |
|
Sequential |
Sequential + parallel |
|
Single memory |
Shared state across agents |
|
Optimize one worker |
Optimize an organization |
Why “graph”?
Because the workflow literally becomes a directed graph.
Imagine
Research
│
▼
Summarize
│
▼
Fact Check
│
┌────┴─────┐
│ │
Pass Fail
│ │
▼ ▼
Publish Rewrite
The graph specifies
- where information flows,
- who receives it,
- which branches execute,
- how failures recover,
- when humans intervene.
This resembles workflow engines and distributed systems, but now many of the nodes are LLM-powered agents rather than deterministic software.
Why this matters
The bottleneck is moving.
Three years ago:
Better prompts → better results.
Today:
Better orchestration → better agents.
In other words,
the scarce skill is becoming
system design rather than prompt writing.
Many people even describe graph engineering as “programming an AI organization instead of programming one AI.”
A philosophical observation
Knowing your interests in Deleuze, assemblages, and self psychology, I think there is an interesting parallel.
Prompt engineering assumes:
One mind solving one problem.
Loop engineering assumes:
One mind becoming reflexive, continuously modifying itself through action and feedback.
Graph engineering assumes:
Intelligence is distributed across an assemblage rather than located in one mind.
That is remarkably close to Deleuze and Guattari’s language of assemblages, rhizomes, and distributed agency. The “thinking” no longer belongs to a single agent but emerges from the coordinated interactions among specialized nodes.
Ironically, AI engineering seems to be rediscovering—through software architecture—ideas that philosophers like Deleuze, Bruno Latour, and Karen Barad have been developing for decades: intelligence is less like a solitary brain and more like a dynamic network of relations.
