Architectures & Orchestration

Single agents, multi-agent systems, planning patterns, and the human in the loop

• Single-Agent Patterns: ReAct, Plan-Then-Execute, Reflection — The three canonical ways to structure one agent — interleaved reasoning and acting, upfront planning, and self-critique — with honest tradeoffs on latency, cost, debuggability, and where each one breaks. (4 lessons, 45 min)
• State Machines vs LLM Loops: Who Owns Control Flow? — The spectrum from fully-coded state machines to free-running LLM loops, what explicit state buys you and what it costs, graph frameworks as the negotiated middle, and the hybrid that actually ships. (5 lessons, 40 min)
• Workflow Patterns: Five Ways to Compose Model Calls — Prompt chaining, routing, parallelization, orchestrator–worker, and evaluator–optimizer — the five workhorse patterns for composing LLM calls in code, the failure mode each one hides, and a decision procedure for picking the right one. (6 lessons, 45 min)
• Multi-Agent Systems: When One Agent Isn’t Enough — Supervisor–worker, peer handoff, and debate — when a second agent genuinely earns its tokens, what the multi-agent tax actually costs, and the failure modes (deadlock, divergent state, telephone-game briefs) that only exist once there is more than one context. (5 lessons, 45 min)
• Subagents and Context Isolation: The Delegation Move — Why the parent’s context window is the scarce resource, how to write a brief a fresh-context subagent can actually execute, what delegation costs in tokens, loss, and latency — and the three patterns (fan-out research, isolated risky work, fresh-eyes review) that earn the overhead. (5 lessons, 40 min)
• Memory Architectures: Engineering the Context at Scale — The context window is a budget, not a bucket. How production agents decide what earns a slot — compaction that doesn’t destroy the truth, countermeasures for context rot on long runs, four long-term stores compared by their retrieval paths, and write policies that keep memory from becoming a poisoning target. (5 lessons, 45 min)
• RAG for Agents: From One-Shot Retrieval to Agentic Search — How retrieval actually works — chunking, embeddings, hybrid search, reranking — and what changes when an agent drives the search loop instead of a fixed pipeline. Plus grounding, citations, and the honest RAG vs long-context vs fine-tuning decision. (5 lessons, 45 min)
• Human-in-the-Loop: Designing the Human Back In — Where human judgment enters the agent loop — the gate spectrum from notify-after to co-draft, which actions deserve gates, why approvals must show the literal tool call, how to pause and resume a run durably, and how to make escalation a designed success. (5 lessons, 40 min)
• The Framework Landscape: Pick One (or None) — What an agent framework actually buys you, what it costs, an honest tour of the 2026 landscape grouped by shape, and when the right framework is a hundred lines of your own code. (4 lessons, 45 min)
• Orchestration End to End: One Request Through the Whole System — The connective-tissue module. One real request traced through routing, fan-out, delegation, state, a human gate and a reply — with the seams the pattern modules cannot show you: who owns control at each hop, what crosses each boundary, what happens when worker three fails, and how the whole thing reads as a single trace. (5 lessons, 50 min)
• Whiteboarding Agent Systems: Drawing the Thing You Built — The communication skill nobody teaches: a small notation for agent systems, the order to put it on the board, four sketches worth knowing from memory, and the script for narrating one in a design review, an interview, or at 2 a.m. during an incident. (6 lessons, 40 min)