Graph engineering is a loop that learned to branch.

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 Manas 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 ManasFlow 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.

1. Prompt

2. Context

3. Harness

4. Loop

5. Graph

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.

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.

The ManasFlow 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 Manas 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 Manas Framework's lock and review protocol exists to catch.

State drift

Two nodes write to the same field with different assumptions about its shape. ManasFlow 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.

Researcher

Pulls source material, drafts a claim list with citations.

Writer

Reads the claim list, writes a draft that cites every claim.

Reviewer

Checks every claim against a source. Flags 2 unverified claims.

Writer (retry)

Cuts the 2 unverified claims, tightens the affected paragraph.

Reviewer (retry)

Re-checks. 13 of 13 claims verified. Approves for publish.

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 info@manasflow.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

Consultation

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 ManasFlow'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

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.

The escalation ladder framing (prompt, context, harness, loop, graph) comes from aibuilderclub's Graph Engineering Guide, published in a July 2026 discussion. ManasFlow did not coin the term. This page uses it to describe a framework we were already running in production, the ManasFlow multi-agent build system, and to credit where the vocabulary came from.

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.

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.

The Manas 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.

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 ManasFlow 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.