Dynatrace's autonomous SRE agents, Microsoft's red/blue/green security topology, KAT-Coder's 100,000 verifiable training environments, and the Claude share-link leak all price the same transition: supervised to autonomous.
Claude Opus 5 sells self-checking, Siemens anchors design agents to physics engines, Neo4j buys GraphAware to challenge Palantir, and MemGraphRAG hands graph construction to a conflict-resolving agent crew.
Temporal knowledge graphs beat memory benchmarks, a 3.7M-view roadmap names the discipline, and the five-layer stack gets its vocabulary. The inaugural digest.
Move beyond isolated prompts and fragile agent loops. Learn to connect agents, models, code, tools, memory, verification, and human decisions into reliable systems you can inspect and ship.
Prompt engineering determines what a model is asked to do. Loop engineering enables an agent to repeatedly reason, act, observe, and adjust. Graph engineering determines how agents, models, tools, code, memory, verification, and human judgment work together as an explicit system.
One instruction produces one response. Powerful, but stateless and blind to consequence.
One agent repeatedly reasons, acts, and observes. Capable — until it becomes impossible to inspect and control.
Specialized agents, tools, code, memory, verification, and humans coordinate through explicit structure.
Graph Engineering Mastery is not a course about making more agents. It is a course about making intelligent systems:
Students use real frameworks and infrastructure in controlled laboratories — not toy sandboxes.
Each module introduces the thinking of important builders, researchers, and educators shaping the field.
A curated continuation path instead of an overwhelming directory of links — opened in a separate “Continue Learning” area.
The purpose is not to master every framework. The purpose is to understand the underlying architecture well enough to move between frameworks.
You will learn where each tool is strong, where it creates unnecessary complexity, and how to select the smallest appropriate stack.
Typed state, conditional routing, parallel execution, cycles, checkpoints, persistence, human interrupts, long-running stateful agents.
Explicit node contracts, typed inputs and outputs, return-type-defined edges, finite-state-machine thinking, runtime detection of invalid transitions.
Sequential, parallel, and loop workflows; multi-agent composition; evaluation and deployment across Python, TypeScript, Go, Java, and Kotlin.
Executors and edges, graph-based workflows, checkpointing, concurrent execution, human-in-the-loop processes. Successor direction to AutoGen, now in maintenance mode.
A deliberately small abstraction layer: agents, runners, tools, handoffs, guardrails, sessions, run traces, usage and cost tracking.
Specialist roles, Crews for autonomous collaboration, Flows for controlled event-driven orchestration, memory, knowledge, guardrails, observability.
Agentic retrieval, document workflows, router agents, multi-document research, structured outputs, event-driven workflow steps.
Declarative LM modules, multi-stage programs, metrics, automated instruction optimization, improving nodes against measurable outcomes.
Entities and relationships, Cypher, provenance, knowledge extraction, graph traversal, GraphRAG, agent memory, explainable retrieval.
Execution traces, node-level inspection, dataset-based evaluation, failure diagnosis, latency analysis, production monitoring. A graph that cannot be observed is not ready for production.
Every module is organized around one central question, two expert lenses, real tool laboratories, and one project output.
The minimum-necessary-architecture rule. Drawing the system before coding. First exercise: classify ten problems as prompt, function, loop, workflow, graph, or human process. Personal Learning Graph activation.
Nodes as bounded responsibilities. Edges as real data dependencies. Input/output contracts, structured state, false dependencies, explicit stopping, finite-state-machine thinking, Mermaid architecture diagrams.
Sequential edges, conditional routing, fan-out, fan-in, joins and reducers, supervisor–worker graphs, specialist routers, handoffs, dynamic versus predetermined execution, human escalation.
Working state, checkpoints, session and durable memory, entity extraction, canonicalization, typed relationships, provenance, confidence, contradictions, GraphRAG, memory consolidation.
Extract → Resolve → Assemble → Verify → Persist → Repeat
Read-only critics, verification gates, evidence checking, bounded repair cycles, node- and graph-level evaluation, dataset creation, metric design, automated optimization, regression testing, cost-quality tradeoffs.
Compare LangGraph, Pydantic Graph, Google ADK, Microsoft Agent Framework, OpenAI Agents SDK, CrewAI, and LlamaIndex Workflows across control, type safety, state, persistence, parallelism, human interaction, observability, knowledge integration, deployment, and learning curve. Students do not choose a framework because it is fashionable — they choose it because its execution model matches the problem.
Tracing, replay, checkpoint recovery, idempotency, retries, timeouts, spend caps, permission boundaries, tool isolation, prompt-injection defense, state migration, versioning, model routing, caching, human approval, graph simplification.
Reuse proven structures instead of reinventing every workflow. Each pattern ships as an editable template.
Use when every step truly depends on the previous step.
A → B → C
Use when independent workers can operate simultaneously.
┌→ B ─┐
A ─────┼→ C ─┼→ E
└→ D ─┘Use when state determines which specialist should act.
Input → Router ─┬→ Specialist A
├→ Specialist B
└→ HumanSplit work, perform it independently, then merge the results.
┌→ Left ─┐
In ─┤ ├→ Merge
└→ Right ─┘One node produces. Another independently evaluates.
Generate → Verify ─┬→ Accept
└→ RepairPause before consequential actions.
Draft → Review ─┬→ Approve
├→ Edit
└→ RejectA coordinator delegates bounded tasks without performing every task itself.
Supervisor ─┬→ Worker A
├→ Worker B
└→ Worker CExtract, resolve, verify, and preserve knowledge across runs.
Extract → Resolve → Assemble ↑ │ Repeat ← Persist ← Verify
Separate fast operational adjustments from slower strategic, safety, and audit decisions.
Fast loop: tune → retry Slow loop: audit → govern
You will not simply watch someone build them. You will draw, run, inspect, repair, and ship them yourself.
These experts form the course's intellectual reference map — GraphEngineerings.com independently synthesizes their public work into one architecture-first learning path.
Co-founder and CEO of LangChain, closely associated with LangGraph and the movement from simple model chains toward persistent, inspectable agent workflows.
Founder of DeepLearning.AI. His agentic curriculum emphasizes reflection, tool use, planning, and multi-agent workflows built first from principles.
Founding researcher at fast.ai. His teaching lets students build useful systems early, then progressively exposes the deeper theory.
Senior author of the original AutoGen research: customizable agents combining models, tools, code, and human input through flexible interaction patterns.
Co-founder and CEO of LlamaIndex; teaches agentic retrieval patterns in which agents route, investigate, and reason across document collections.
Founder of CrewAI; teaches the organization of specialized agents using roles, memory, tools, collaboration, guardrails, and controlled flows.
Creator of Pydantic; leads the ecosystem containing PydanticAI, Pydantic Graph, evaluation, durable-execution integrations, and Logfire observability.
Led the creation of DSPy, which models LM applications as modular computational graphs optimized against measurable outcomes.
His work includes DSPy and related systems for optimizing AI programs, prompts, code, and semantic computation.
CEO and co-founder of Neo4j; has spent his career building and advocating graph databases and the property-graph model.
When a field article teaches something our courses don’t, we integrate it as new lessons and its author joins this roster. Each card links to the exact work — and to where it landed in the curriculum.
His Claude Opus 5 Prompting Masterclass distilled Anthropic’s official guide: the effort dial, why-not-what prompting, deleting verification instructions, the agentic fence. → Prompts course, lessons 06–09
His 14-step context-engineering roadmap mapped the startup ledger, the four failure modes, delete-first discipline, and interface-over-example tool design (→ Context course, lessons 06–09), and his 9.3M-view loop-engineering roadmap added the loop economics test, the Ralph Wiggum failure mode, and the security tax (→ Loops course, lessons 11–12), and his 4.9M-view graph-engineering roadmap completed the trilogy: edges are free, barriers are not (→ Module 2, lesson 2.7)
Their agent-loop deep dive gave us the four-question loop test, the six building blocks, and cost-per-accepted-result. → Loops course, lessons 06–08
His pattern taxonomy named the three failures — agentic laziness, self-preferential bias, goal drift — and the six patterns that cure them. → Module 2, lesson 2.5
Their 606K-view Harness vs. Loop vs. Graph Engineering guide gave us the environment → feedback → flow nesting, the failure-diagnosis table, and the five expensive mistakes. → Harness course, lessons 06–08
Her Graph Engineering for Quants masterclass gave us the third meaning of the word: GNNs that predict from the neighborhood, and the no-look-ahead rule for data-derived graphs. → Module 0, lesson 0.3
His open-source Loop Engineering project gave us the L0–L3 autonomy ramp, report-only-first adoption, the Loop Ready audit, and the failure-mode catalog — verifier theater included. → Loops course, lessons 09–10
His July 2026 note “The Karpathy Loop, Improved 1000× by Itself” gave us externalize-the-bottleneck, the ratchet loop, the commit-DAG–vs–knowledge-graph split, and the traceability invariant. → Module 0, lesson 0.6 · Module 3, lesson 3.5
His 6¾-hour Graph Theory course grounds our mappings: topological sort as the scheduler, DAG longest path as the critical path, Tarjan’s SCCs as the cycle detector, articulation points as single points of failure. → Module 1, lesson 1.5
His “A Graph of Loops” — ten repos read at the source — gave us the composition rule (every node is an agent running a loop), the take-done-back test, and code-not-models as the final gate. → Module 2, lesson 2.6
Their Alpha Orchestration Layer guide gave us reliability shrinkage, hidden-redundancy neutralization, risk-parity budgets, netting, constraints-in-the-solve, and snapshot isolation. → Module 2, lessons 2.8–2.9
Their 458K-view 11-step Obsidian-to-graph roadmap gave us the router-and-index architecture, one-idea-per-file nodes, retrieval as logic, and the prove-it benchmark. → Module 3, lesson 3.6
Their 348K-view Eval Engineering course gave us judge-family bias, cross-vendor panels, verdicts that steer runs, trace-mined evals, pin-the-judge, and the blast-radius gate. → Module 4, lessons 4.5–4.6
Their Context Engineering pipeline article gave us ingest-with-provenance, three-signal ranking, routing that picks context and model tier together, and compression-not-truncation. → Context course, lessons 10–11
Their 107K-view Graph Engineering with Claude fleet guide gave us the fake-edge test, layered fan-in, hidden edges, count-your-inputs, anchors and frozen rules, and the cap-first / earn-the-scale protocol. → Module 2, lessons 2.10–2.11
Their 361K-view Claude Certified Architect exam guide gave us hooks-vs-prompts, stop_reason discipline, permission evaluation order, the read-tool equivalence trap, and the self-disabling sandbox finding. → Harness course, lessons 09–10
Their fleet-architecture distillation sharpened the anchors principle: “a graph without anchors is just a more sophisticated way to be confidently wrong.” → Module 2, lesson 2.11
Lessons take 8–15 minutes. No long passive lecture is required before you begin building.
One concise architectural principle.
How one relevant expert or project approaches the problem.
A comparison of how two frameworks represent the same idea.
A runnable micro-project.
Automated structural and output evaluation.
The result is added to your Personal Learning Graph.
A curated continuation path, not an overwhelming directory of links — each chosen for what it does best.
Practical-first AI foundations; build working applications early.
Reflection, tool use, planning, and multi-agent patterns from first principles.
The bridge from a Python agent loop to a flow-based LangGraph application.
The official structured introduction to state, nodes, edges, memory, and orchestration.
Plan, build, debug, observe, and deploy role-based multi-agent systems.
Routers, tools, research agents, and multi-document reasoning.
Design patterns for collaboration and reflection — studied as a historical framework.
Broad free path: fundamentals, smolagents, LlamaIndex, LangGraph, Agentic RAG, certification.
Agent skills, MCP, plugins, subagents, lifecycle hooks, and a minimal agent harness.
Graph fundamentals, GraphRAG, knowledge construction, retrieval, and production graph apps.
The credential is issued for a working, explainable graph — not for merely watching lessons.
Graph Engineering Mastery brings together the best current ideas from agent orchestration, graph databases, context engineering, workflow systems, AI evaluation, and practical technical education. But the objective is not to produce a student who knows ten framework names. The objective is to produce a builder who can look at a complex problem and determine: