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