Central question: Which implementation best fits this graph?
The judgment module. Ten dimensions, three execution models, one-tool-per-layer discipline, and the port that shows you exactly where your lock-in lives.
Framework choice is an engineering decision with ten dimensions: control, type safety, state, persistence, parallelism, human interaction, observability, knowledge integration, deployment, learning curve. The course principle: you do not choose a framework because it is fashionable; you choose it because its execution model matches the problem. Half the frameworks on your shortlist exist because their vendor needed them to.
One of the loudest replies to the graph-engineering discourse was 'welcome back, langchain' — the name is new, the practice isn't. The skill is seeing through renames to execution models.
The seven on the bench: LangGraph, Pydantic Graph, Google ADK, Microsoft Agent Framework, OpenAI Agents SDK, CrewAI, LlamaIndex Workflows.
Score all seven frameworks 1–5 on the ten dimensions from what you've built so far — a real scorecard, not vibes. Leave blank what you haven't touched; blanks are data too.
Defend your two lowest and two highest scores with a concrete experience from a module lab. No lab evidence, no score.
Adds framework-scorecard — a living artifact you'll re-score for years.
Under the branding, three execution models. Graph-first (LangGraph, Pydantic Graph, Microsoft AF): you draw nodes and edges; control flow is the artifact. Role-first (CrewAI, OpenAI SDK handoffs): you cast a team; coordination emerges from roles and handoffs. Event-first (LlamaIndex Workflows, CrewAI Flows): steps subscribe to events; topology is implicit in the subscriptions. Each hides a different thing — and what a framework hides is what you'll debug at 2 a.m.
Chi Wang's AutoGen proved conversational multi-agent patterns and then Microsoft moved production work to the typed Agent Framework: the field's own migration from emergent to explicit.
The same reviewer-rejection loop is one conditional edge (graph-first), a role instruction (role-first), or an event re-emission (event-first). Write all three; feel where the logic lives.
Implement the tiny review-reject-retry loop in one framework from each family — three implementations, ~40 lines each.
For each: point to the exact line where 'reject routes back to writer' lives. If you can't point to it, the framework owns it, not you.
Adds execution-models; this is the lens that makes every future framework announcement boring.
Real systems mix layers, not frameworks: an orchestration layer, a memory layer, an observability layer. The discipline is one tool per layer, chosen by the dimension your problem actually stresses — a document-heavy system stresses knowledge integration (LlamaIndex + Neo4j); a compliance workflow stresses typed control and human gates (Microsoft AF or LangGraph). Adding a second orchestrator is how architectures rot.
Every expert in this course built one layer exceptionally well; none of them recommends using all ten tools at once. The spec's own rule: use only the minimum stack your project requires.
Write the decision as an architecture-decision record: the two dimensions your problem stresses, the one tool per layer, and what you deliberately left out.
For your intended capstone, write the ADR: stressed dimensions, chosen stack (max three tools), rejected alternatives with one honest sentence each.
A reviewer (human or fresh AI) must be able to reconstruct your problem's shape from the ADR alone. If they guess a different stack, your stressed dimensions were wrong.
Adds minimum-stack; Module 6 holds you to it.
Nothing reveals a framework like porting away from it. Implementing one architecture twice exposes what was your design (it ports cleanly) versus what was the framework's opinion (it fights you). The parts that fight are your lock-in — know them before production, not after.
The Bun rewrite is the industrial-scale version of this exercise; yours is four nodes, but the lesson is identical: the test suite is the invariant, the implementation is disposable.
Port your Module 1 typed graph between any two families from 5.2. Keep the Module 4 evaluation dataset as the fixed contract both must pass.
Port it. Log every place the second framework forced a design change — that log is the deliverable, not the code.
Both implementations pass the same evaluation suite with statistically indistinguishable metrics. The friction log has at least three honest entries.
Completes the studio: you are now framework-portable, which is the only durable form of framework expertise.
Lesson 1 of every module is open. The full module — all lessons, the tool lab, and the graded project — unlocks with any plan.
Try Free — 30 Days (no card) Own the course — $6.93 Compare plansPurchased already? Sign in with your checkout email.
Guided tours of all seven frameworks running the same miniature graph, with the ten-dimension scorecard filled as you go. By the end the frameworks stop being brands and become three execution models wearing different jackets.
Implement one small architecture in two frameworks from different execution-model families and defend the tradeoffs.
Acceptance criteria — all must be demonstrably true: