Agentic patterns, explained simply.
Orchestration, routing, multi-agent… they sound like guru-level architecture, but they're simple ideas. Every pattern is explained with a simulation you can play with, until you understand when to use it — and when NOT to.
If any of this rings a bell, this course is for you
Whether you already build with LLMs or come from years of classic engineering: here you build the judgment tutorials don't teach.
You copy architectures from tutorials — multi-agent, RAG, whatever's trending — without knowing if your problem needs them.
Your agent gets stuck in loops, hallucinates, or drifts from its instructions, and you don't know where to grab it.
Cost and latency blow up on you and you don't know what's burning them: tokens, context, serial calls…
You've spent years in software engineering and want to understand agents with the same depth as your systems.
By the end, you design agentic systems with judgment
Each pattern's mechanics
You watch the flow in simulation: what the LLM does at each step, where data travels, where state lives, and where the gates are.
Knowing what your problem needs
Latency, goal ambiguity, tool needs, reliability: you identify which pattern fits your case — without copying trendy architectures.
The “when NOT to”
You recognize over-engineering and hidden costs (latency, tokens, complexity) before building the system, not after.
Composing and reading architectures
You combine patterns (Routing + Tool Use + Reflection) for a real case and recognize the pattern in LangGraph or OpenAI Agents SDK code.
6 tracks · 47 lessons
Progressive launch: the first lessons are already available, with new ones released every week.
The primitives every pattern uses but the catalogue never teaches: tokens and cost, classification and confidence, sampling, embeddings, judges, and bounded loops.
- The agentic patterns landscape
- Tokens, context, and cost
- Classification & confidence scores
- Why the same prompt gives different answers: sampling and temperature
- Embeddings & semantic similarity
- Quality scoring & LLM-as-judge
- Tool schema & structured call
- Bounded feedback loop
The five canonical workflow patterns — and the augmented LLM they all start from. Each one anchored to its classic software-engineering equivalent.
- Augmented LLM
- Prompt Chaining
- Routing
- Parallelization
- Orchestrator-Workers
- Evaluator-Optimizer
What turns a call into an agent: tools, RAG, planning, the ReAct loop, reasoning, reflection, and memory.
- Reading graphs & trees
- Top-k retrieval & chunking
- Tool Use
- RAG / knowledge retrieval
- Planning
- The agentic loop (ReAct)
- Reasoning techniques
- Reflection
- Memory management
- Goal setting & monitoring
From local calls to distributed systems: call boundaries, retries, MCP, inter-agent communication, and human-in-the-loop.
- From local calls to connected systems
- Call boundary: in-process vs remote
- Retries, backoff & error taxonomy
- MCP / state management
- A2A / inter-agent communication
- Human-in-the-loop
Making it work in the demo is the easy part. Evaluation, prompt injection, context engineering, traces, guardrails, and agent security.
- From making it work to surviving production
- Eval set: precision & recall
- Prompt injection & trust boundary
- Context engineering
- Exception handling & recovery
- Instruction drift mitigation
- Explainable agent trace
- Resource-aware optimization
- Evaluation & monitoring
- Guardrails & safety
- Agent security
Cooperation topologies, hierarchies, and fault-tolerant meshes — and the close: choosing and composing patterns for a real case.
- Multi-agent collaboration
- Cooperation topologies
- Hierarchical orchestrator
- Fault-tolerant agent mesh
- Pattern selection criteria
- Pattern composition