Grokking Agentic Design Patterns
Design agents that act safely, recover from failure, and justify their cost.
Course Overview
An agent that works in a demo can still fail in production. It can lose track of its task, report success without checking the result, repeat a payment after a crash, or follow an instruction hidden in an email. Grokking Agentic Design Patterns teaches you how to design against these failures. You will learn the patterns engineers use to structure agents: workflows, tools, planning, context, human approval, guardrails, security, evaluation, memory, and multi-agent coordination. Each lesson explains what a pattern does, how it works, what it costs, and when a simpler design is better. Worked examples use token counts and failure rates, so you can estimate a design before you build it. The course does not depend on any framework or model vendor. It is for software engineers, tech leads, and architects who design agents or review agent designs. You need no machine learning background. By the end, you will be able to take a product brief and produce a complete agent design, including its tools, permissions, evaluations, and cost.
What you'll learn in Grokking Agentic Design Patterns
- Decide when a direct model call or a fixed workflow is better than an agent, and when an agent earns its cost.
- Apply the workflow patterns: prompt chaining, routing, parallelization, evaluator optimizer, and structured output.
- Choose a planning pattern, from reasoning between actions to plan then execute, replanning, and reflection.
- Place human approval where it matters, classify actions by risk, and design escalation that people will read.
- Defend against prompt injection with least privilege, isolation, and the patterns that restrict what can act.
- Design memory that knows what to store, recall, and forget, and keep it accurate over months of use.
- Cut cost and latency with prompt caching, model routing, tool result caching, and parallel tool calls.
- Estimate an agent design before building it, using step counts, token totals, and per-step failure rates.
- Design tools a model can use well, with clear contracts, useful errors, and a clean split between reads and writes.
- Manage the context window as a budget with compaction, structured handoffs, instruction files, and skills.
- Layer guardrails on input, tool calls, and output, and verify outcomes against real state instead of claims.
- Build an eval set from real failures, grade whole trajectories, and debug a failed run from its trace.
- Decide when several agents beat one, and design orchestrator workers, pipelines, and their contracts.
- Produce complete agent designs, with tools, permissions, evaluations, and cost, from a product brief.
Course Content
What an Agent Is and When to Build One
Tool Use Patterns
Function Calling: The Request, Execute, Return Cycle
Designing a Tool the Model Can Use
Tool Granularity, Namespacing, and Dynamic Selection
Tool Results: What a Response Should Contain and What an Error Should Say
Code Execution as a General Tool
Retrieval as a Tool: Searching on Demand and Agentic RAG
Acting on the Outside World: Read and Write Tools and Reversibility
Case Study: The Tool Set for Desk
Chapter Assessment: Tool Use Patterns
Planning and Reasoning Patterns
Reasoning Between Actions: Prompted and Native
Task Decomposition and Explicit Task Lists
Plan Then Execute
Replanning: Detecting Drift and Stalled Progress
Reflection and Self Critique
Exploration: Multiple Candidates, Scoring, and Pruning
Choosing a Planning Pattern
Chapter Assessment: Planning and Reasoning Patterns
Context Engineering Patterns
The Context Window as a Budget
How Specific a System Prompt Should Be
Compaction: Summarizing History Without Losing the Task
Context Resets and Structured Handoffs
Instruction Files and Scoped Context Assembly
Deterministic Lifecycle Hooks
Skills: Packaged Procedures with Progressive Disclosure
Chapter Assessment: Context Engineering Patterns
Human Oversight Patterns
Autonomy Levels per Action
Approval Checkpoints and Risk Classification
Approval Fatigue: When Reviewers Stop Reading
Escalation: The Agent Hands Off When Uncertain
Steering, Interruption, and Pause Resume
Feedback Capture: Corrections Become Evals and Memory
Case Study: Checkpoints for Desk
Chapter Assessment: Human Oversight Patterns
Reliability and Guardrail Patterns
How Agents Fail: A Taxonomy
Guardrail Layering: Input, Tool Call, Output
Outcome Verification: Check the State, Not the Claim
Grounding: Citations and Checking Claims Against Sources
Least Privilege: Permission Design and Scoped Credentials
Identity and Delegation: Acting on Behalf of a User
Sandboxing and Containment
Execution Budgets: Steps, Time, Tokens, Money
Circuit Breakers and Stop Controls
Durable State: Checkpoints, Resume, and Side Effects
Exception Handling and Recovery
Chapter Assessment: Reliability and Guardrail Patterns
Security Patterns
Prompt Injection: The Core Problem
Where Injection Enters: Content, Tool Descriptions, Memory, Other Agents, Skills
Three Properties That Make an Agent Exploitable: The Lethal Trifecta and the Rule of Two
Dual LLM: Privileged Planner, Quarantined Reader
Restrict What Can Act: Action Selector, Plan Then Execute, Context Minimization
Isolate What Reads: Map Reduce and Code Then Execute
Probabilistic Defenses: What the Model Gives You and What You Add
Other Agent Risks: Supply Chain, Code Execution, and Misplaced Human Trust
Case Study: Securing Mailbox With Web Access
Chapter Assessment: Security Patterns
Evaluation and Observability Patterns
Why Agent Evaluation Is Different, and Its Vocabulary
The First Eval Set From Real Failures
Grader Types: Code Based, Model Based, Human
Evaluating Trajectories
Capability Evals vs Regression Evals
Tracing and Trajectory Logging
Debugging a Failed Run From Its Trace
Eval Driven Development
Case Study: The Eval Set for Desk
Chapter Assessment: Evaluation and Observability Patterns
Memory Patterns
Kinds of Memory, and What to Store, Recall, and Forget
Tiered Memory and Just in Time Loading
Structured Note Taking: Scratchpads, Task Files, Progress Files
Retrieval Backed Memory: Files vs Embedding Stores
Memory Consolidation and Staleness
Case Study: Forge Across Many Sessions
Case Study: Mailbox for One User Over Months
Chapter Assessment: Memory Patterns
Multi Agent Patterns
When One Agent Is Not Enough
Orchestrator Workers
Context Isolated Sub Agents and Fork Join
Sequential Pipelines and Handoffs
Group Chat, Debate, and Maker Checker Loops
Communication Contracts: Shared State vs Message Passing
Failure Containment and the Cost of Coordination
Case Study: Scout as Orchestrator Workers
Chapter Assessment: Multi Agent Patterns
Cost, Latency, and Scale Patterns
The Token Economics of an Agent Loop
Prompt Caching and Cache Friendly Loop Design
Model Routing and Tiering
Tool Result Caching and Deduplication
Latency Patterns: Streaming, Parallel Tool Calls, Speculative Work
Serving Infrastructure: Queues, Rate Limits, and Rainbow Deployments
Background Agents: Triggers, Isolation, and Reporting Back
Case Study: Desk's Cost Reduced
Chapter Assessment: Cost, Latency, and Scale Patterns
Interoperability and Change
Model Context Protocol: Servers, Clients, Tools, Resources, Prompts
Agent to Agent Protocols: Agent Cards, Delegation, Task Streaming
What a Framework Gives You: Build or Adopt
Designing for Portability: Keeping the Pattern Independent of the Vendor
Retiring Harness Parts When Models Improve
Chapter Assessment: Interoperability and Change
Full Designs and the Pattern Catalog
Final Exam
Appendix
What people say about our courses
About the Author
Arslan Ahmad
Industry Expertise & Leadership
Arslan Ahmad is the lead author of Grokking Agentic Design Patterns. As the founder of Design Gurus and a former FAANG hiring manager, he has worked at industry giants like Facebook (now Meta) and Microsoft.
He has conducted hundreds of system design interviews, giving him unique insight into what top tech companies look for in candidates.
The course also incorporates expertise from senior engineers at Google, Meta, Amazon, Microsoft, and Uber, ensuring you learn system design best practices from professionals who have built and scaled real-world systems.
500+
Interviews Conducted
10k+
Students Taught
Related Courses
$98
$72
$98
FAQs
What is Grokking Agentic Design Patterns?
It is a text course on how to design AI agents that act safely, recover from failure, and justify their cost. Each lesson explains what a pattern does, how it works, what it costs, and when a simpler design is better, and worked examples use token counts and failure rates so you can estimate a design before you build it.
Who is this course for?
It is for software engineers, tech leads, and architects who design agents or review agent designs. It suits anyone who has seen an agent work in a demo and needs it to work in production, with real permissions, real customers, and a real budget.
Do I need a machine learning background?
No. You should be able to read JSON and short pseudocode, and you should know what an HTTP API call, a retry, and a timeout are. The course defines every other term where it first appears.
Does the course use a framework such as LangChain or a specific model vendor?
No. The patterns are taught independently of any framework or vendor, and the code is short pseudocode and API-shaped JSON rather than a vendor SDK. One lesson covers what a framework gives you and when to adopt one, and an appendix collects implementation notes on the protocols and standards that agents build on.
Is this a course on agentic system design?
Yes. Agentic system design is the work of deciding an agent's goal, autonomy, tools, context, memory, guardrails, evaluations, and cost, and the course teaches each of those decisions. A design worksheet introduced early in the course collects them, and the full designs fill it in from start to finish.
What full designs does the course include?
Five complete designs, each stated as a design question: a customer support agent, a coding agent, a data analysis agent, a browser automation agent, and an incident response agent. A capstone then gives you a blank brief to design on your own, and a pattern catalog closes the course as a reference.
Will this course help me prepare for agent design rounds?
Yes. The full designs are posed as design questions of the kind that agent design rounds ask, and working through them gives you a structure for answering one. The lessons themselves teach the subject rather than interview technique, so what you learn applies directly to production work.
How is this different from Grokking the AI System Design Interview?
Grokking the AI System Design Interview covers designing AI systems broadly, such as retrieval, model serving, and recommendation, and it is shaped around the interview. This course goes deep on one kind of system, the agent, and teaches the patterns for its tools, planning, context, oversight, security, evaluation, memory, and coordination. The two complement each other.
Does the course cover security and prompt injection?
Yes, in depth. It explains why prompt injection is a design problem rather than a filtering problem, where injected instructions enter an agent, which combinations of capabilities make an agent exploitable, and the patterns that limit damage, such as least privilege, a quarantined reader, and restricting which parts can act.
Is there any practice, or is it only reading?
Every lesson ends with practice questions and folded answers. Each chapter ends with an adaptive assessment that draws a fresh set of questions on every attempt, the course closes with an adaptive final exam across all chapters, and the capstone asks you to produce a complete design from a blank brief.
Will the course go out of date as models improve?
The patterns are written to outlast any one model or vendor, and one lesson covers how to retire parts of an agent harness when models improve. Vendor and protocol details that change quickly are kept together in the appendix, which states when it was checked.
