Now open in offline mode (no live sessions) due to high demand — enroll anytime and earn the same certificate.
Mastering Graph Engineering
A complete map of what comes after the single-agent while-loop: composable workflow patterns, production multi-agent systems, knowledge graph construction, GraphRAG-style retrieval, and fusing the commit DAG with the knowledge graph into one governed production architecture.
Based on your location (India), you qualify for a Purchasing Power Parity discount.
Secure checkout via Razorpay
India checkout supports cards, UPI, net banking, and eligible EMI through Razorpay.
About this program
A single agent in a while-loop is the correct answer to a huge number of problems — this course says so early and often. But once success is verifiable, work is parallel, or facts need to outlive a single run, the loop becomes the wrong shape. This course teaches everything that comes after as one continuous architecture, not six unrelated frameworks: the node/edge/contract vocabulary; Karpathy's autoresearch ratchet loop and the AgentHub commit-DAG sketch; Anthropic's five composable workflow patterns plus dynamic, Claude-written orchestration and verification-as-graph-structure; production multi-agent systems drawn from Anthropic's own research system and Andrew Ng's agentic design patterns; agentic knowledge graph construction from zero, including graph database fundamentals; GraphRAG-style retrieval and its cheaper successors; fusing the commit DAG and knowledge graph so a worker can ask both "what changed" and "what's true"; and finally a five-plane production architecture, governance, failure modes, and a capstone that ships a graph-grounded swarm. 7 modules, 17 lessons, fully self-paced — no live sessions required.
Who is this for?
Engineers and technical builders who already ship LLM calls and single-agent loops, and want a systematic map of orchestration, multi-agent, and knowledge-graph architecture beyond the loop
What you'll actively build & learn
Understanding Fundamentals
Grasp the core mechanics of AI systems, from transformers to retrieval algorithms, moving beyond superficial APIs.
Production-Ready Architecture
Learn how to architect scalable, resilient generative AI applications that handle edge cases and high throughput.
Hands-on Engineering
Write custom PyTorch models, build multi-agent swarms using LangGraph, and deploy to Kubernetes.
Verifiable Execution
Complete rigorous capstone projects that serve as a proof-of-work portfolio for your next AI engineering role.
Time Commitment & Schedule
Self-Paced Modules
Flexible
No live sessions — work through all 7 modules whenever suits you, in any order you need.
Hands-On Labs
~18 hrs total
Labs in every module: a reflective loop with an explicit evaluator, generated JavaScript orchestration with parallel() and pipeline(), an adversarial review loop, agentic knowledge graph construction, fused commit-DAG/knowledge-graph retrieval, and a capstone that ships a graph-grounded swarm.
Module-Based Syllabus
Each module is structured around three things: what you'll cover, what capability you'll walk away with, and the concrete deliverable that moves you toward a working system of your own. Work through them in any order, at any pace.
7 self-paced modules, 17 lessons — work through them in order or jump to the pattern you need most right now
A working architecture vocabulary for graphs vs. loops, a personal toolkit of composable orchestration and knowledge-graph patterns, and a capstone project that ships a graph-grounded system
Practitioner-first lessons grounded in real production write-ups from Karpathy, Anthropic, and Andrew Ng, with hands-on labs that produce artefacts you can reuse immediately
Orientation & Foundations
- Where a loop is still the right answer, and the node/edge vocabulary used for every module after this one: bounded jobs, real edges, contracts, and free vs.
- paid edges.
The ability to draw any agentic script as nodes and edges, and to redraw-test whether an arrow is actually an edge.
A course map and tool stack setup (Claude Code / Claude API, Python, NetworkX, a Neo4j sandbox), plus a contract-annotated diagram of a simple agent script.
Karpathy's Lineage — Loop to DAG
- The three-file autoresearch harness and ratchet template, and AgentHub's commit DAG as the literal graph of agent collaboration, with the CLI and message board as graph interfaces.
The ability to build a reflective loop with an explicit evaluator and a stopping rule, and to reason over a commit DAG's lineage.
A reflective loop with a stopping rule, plus a modeled experiment tree answering four lineage questions.
Anthropic's Workflow Patterns
- The five composable patterns (chaining, routing, parallelization, orchestrator-workers, evaluator-optimizer) and their decision table; generated JavaScript orchestration with parallel() and pipeline(); verification as a graph node; and tiering models against a declared complexity budget.
The ability to choose the right composable pattern for a task and enforce a cost/latency budget across a graph.
A generated-orchestration pipeline using parallel() and pipeline(), plus an adversarial verify loop with dedupe-against-everything-seen.
Multi-Agent Systems in Production
- Anthropic's own lead-agent/subagent research system deployment, the token-cost trade-off it accepts, and Andrew Ng's four agentic design patterns plus the autonomy spectrum.
The ability to decide when a multi-agent system's value clears its ~15x token-cost bar, and to design a planner → parallel-researchers → writer → editor pipeline.
A four-agent incident-response-style factory with a lead agent that writes its plan to memory before delegating.
Knowledge Graphs as Shared Memory
- Replacing a classical NLP pipeline with schema-constrained extraction, description-based entity resolution, and provenance-tagged graph assembly; multi-agent graph builders on Google ADK; and graph database fundamentals from zero, including Cypher.
The ability to construct a provenance-tagged knowledge graph from unstructured documents without a trained NER or relation classifier.
A knowledge graph built via agentic extraction, resolution, and assembly, queried with a bounded-subgraph traversal.
Retrieval and Fusion
- GraphRAG's community detection and hierarchical summaries for local vs.
- global search, the cheaper successors (LazyGraphRAG, HippoRAG, PathRAG), and explicitly fusing the commit DAG with the knowledge graph.
The ability to build task-specific context from a fused graph: resolve entities, bound hop expansion, prioritize verified claims, and attach citable edge identifiers.
A hybrid retrieval query path merging vector similarity with graph traversal, joined against a small commit-DAG/knowledge-graph fusion.
Production, Governance & Capstone
- The five-plane production architecture (control, execution, artifact, graph, evaluation), the production checklist, monitoring signals, catastrophic failure modes, and the six selection questions for whether to build a graph at all.
The ability to operate a graph-grounded system in production with budgets, monitoring, recovery, and governance — and to know when not to build a graph.
A shipped, graph-grounded swarm (chosen from six capstone shapes) with a working repo, an architecture diagram, and every output traced to an objective, plan, artifact, source, graph path, evaluator decision, and bounded execution record.
The syllabus builds toward a final proof of work.
The weekly syllabus is designed to stack toward a capstone that demonstrates what you can actually build. By the end of the cohort, you are not just finishing modules. You are presenting a concrete output that ties the learning arc together.
View Alumni CapstonesIndustry-Grade Certification
Earn a credential that actually matters. Every certificate is tied to your Capstone Project repo, valid for life, and optimized for your professional technical profile.
View Certification TiersYour instructor
Anubhav Srivastava
Anubhav has spent the past two decades building machine learning and AI systems across startups, large enterprises, and high-scale consumer platforms. He has worked on patented AI technologies, authored books, and founded multiple ventures, and is currently building a deeptech startup focused on physical AI. Known for combining technical depth with practical thinking, he enjoys breaking down complex ideas into clear, accessible insights and is driven by a curiosity for how technology can solve real-world problems.
From our students
Engineers at different levels share what they built and what changed.
500+
Engineers trained
25+
Engineering leaders
40+
SaaS startups
50+
Alumni network
Alumni at
“The most technically rigorous program I've attended. No fluff — just pure deep-dives into transformer blocks and swarm logic. It's about understanding how LLMs actually work.”
Siddharth S.
Staff Engineer · Build Your Own LLM
“LangGraph and multi-agent orchestration was the missing link for our production pipeline. Essential for developers who need to move beyond single-prompt engineering.”
Elena R.
Senior AI Engineer · Agentic AI
“Direct access to instructors who are actually shipping AI products. The focus on evals-driven development is unique — we implemented their RAG evaluation approach across our entire startup.”
Arjun R.
Tech Lead · Claude Code
FAQ
Common questions about courses, formats, and what to expect.