Graph Engineering Cheat Sheet

By the Syncfusion DevTutorials team · Last updated October 19, 2026

One page to come back to: loop or graph, the graph file format, the five patterns, state contract rules, exits, caps, join policies, gates, the scorecard, graph pack files per tool, and an error index for every linter rule.

How to Use This Page

This page collects everything from the course in one place: the decision, the file format, the patterns, the rules, the files for each tool, and every message the Graph Lab can show you. Keep it open while you build.

Loop or Graph?

Start with one loop. Add nodes only when you can name what they buy.

Research on 260 agent setups: extra agents helped independent, parallel work by up to 80.8%, made strict step-by-step planning 39–70% worse, and hurt tasks one agent already did well.

The Five Patterns

Graph File Template

Each node on one line. Copy this and change it.

graph: my-graph
checkpoint: after_each_node
kill_switch: GRAPH_PAUSED
nodes:
  - { id: route, kind: router, model: large, min_confidence: 0.7, reads: [ticket], writes: [route, risk_reason] }
  - { id: quick_fix, kind: agent, model: small, reads: [ticket], writes: [diff], exit: { checker: npm test, max_iterations: 4 } }
  - { id: careful_fix, kind: agent, model: large, on_bound: escalate, reads: [ticket], writes: [careful_diff, test_result], exit: { checker: npm test, max_iterations: 8, oscillation: true, no_progress: 2, flat_score: 3, budget: 20000 } }
  - { id: approve, kind: gate, evidence: [careful_diff, test_result, risk_reason], reads: [careful_diff, test_result, risk_reason], writes: [approval] }
  - { id: merge, kind: function, reads: [diff, careful_diff, approval], writes: [merged] }
edges:
  - { from: route, to: quick_fix, when: risk == low }
  - { from: route, to: careful_fix, when: risk == high }
  - { from: route, to: careful_fix, when: else }
  - { from: careful_fix, to: careful_fix }
  - { from: quick_fix, to: merge }
  - { from: careful_fix, to: approve }
  - { from: approve, to: merge }
state:
  route: { type: "low | high", writer: route }
  careful_diff: { type: diff, writer: careful_fix }
  test_result: { type: "pass | fail", writer: careful_fix }
  approval: { type: "approve | reject", writer: approve }

Node Kinds

Edge Kinds

State Contract Rules

1. Every field has one writer.
2. Every node lists the fields it reads. Nobody reads *.
3. Fields another node decides with get a small, exact type.
4. Handoffs between chained nodes are typed shapes, like "{cause, steps, file}".
5. checkpoint: after_each_node saves the state, so a crash resumes and a gate can wait.

Limits at a Glance

The Scorecard

A graph is graded on its run, never on its drawing.

Graphs in Each Tool

Graph Pack Files

None of the three tools has a visual graph runtime. The main agent follows graph.md and calls one subagent per node.

Debugging a Run

1. Find a run that worked on the same kind of input.
2. Read both logs from the top: node, inputs, tokens, time, verdict.
3. The first row that differs is the cause. Rows after it are effects.
4. Fix that node only, and run again.

Human Gates

• Gate the paths with a large blast radius: auth, payments, data migrations.
• Show the diff, the test result and the risk reason.
• Never gate the quick path. Too many approvals means nobody reads them.
• Ticket text never decides whether it needs review.

First Real Run Checklist

• Run the test command by hand once.
• Create GRAPH_PAUSED, start the graph, check that it stops. Delete the file.
• Run the graph on 2 or 3 small tickets.
• Change a state field by hand between two nodes. The supervisor must stop the graph.
• Check that graph-state.json updates after every node.
• Read every diff on the first day.

Error Index

The Graph Lab's linter rules and the common check messages, what causes them, and the fix. A check message starts with the version it failed on, for example "Version 2: …".

Graph Linter

Check Messages

Glossary

• Node: one step of work: code, a model call, an agent loop, a router, a join, an orchestrator or a gate.
• Edge: a route from one node to the next: fixed, conditional, loop-back or fan-out.
• Shared state: the typed record that travels with the work.
• State contract: each field's type, its one writer and its readers.
• Handoff: the field one node writes for the next.
• Join policy: what a join does when a branch is missing: all, quorum or partial.
• Caps: limits on an orchestrator's width, depth and spend.
• Realized topology: what a run actually started.
• Stopped on bound: a loop that stopped because an exit fired, not because it failed.
• Blast radius: how much damage a wrong change can do.
• Graph pack: the exported files: graph.md, subagents, state contract, supervisor, notes.

Further Reading

• How to Implement Graph Engineering, by QA Wolf
• Building Effective Agents, by Anthropic
• Graph Engineering vs Loop Engineering, by AI Builder Club
• Prompt vs Loop vs Graph Engineering, by MarkTechPost
• graphkit, by levi-qiao
• Building Coding Agent Workflows with Loop Engineering, on GoPenAI
• Loop Engineering, by Addy Osmani
• Claude Code subagents · Codex subagents · Cursor subagents