0% completed
Who Is This Course For
On This Page
Who This Course Is For
What You Need Before You Start
What This Course Is Not
What the Course Covers
How Each Lesson Works
How to Practice
An agent that works in a demo can still fail in production. It can lose track of its task, report a refund that never happened, repeat a payment after a crash, or follow an instruction hidden in an email. Most of these failures are not caused by a weak model. They are caused by design decisions: which tools the agent has, what it may do without asking, what it remembers, and how anyone knows that it worked.
This course teaches those decisions. This page explains who the course is written for, what you need before you start, and what the course covers.
Who This Course Is For
This course is for engineers who design agents or review agent designs. In this course, an agent is a program in which a language model chooses the next step. Your code carries out that step, and the loop repeats until the task is done. The first lesson defines this carefully.
The course is written for four kinds of readers:
- Software engineers who are building their first agent, or whose agent works in testing and fails with real users.
- Tech leads who must decide whether a task needs an agent at all, and what the agent should be allowed to do.
- Architects who review agent designs for safety, cost, and reliability before they reach production.
- Engineers who own systems that an agent will call, such as a payment service or a ticket system, and who need to know what the agent can and cannot be trusted to do.
What You Need Before You Start
You need no background in machine learning. The course never asks you to train a model or to understand how a model works inside. It treats the model as a part that is usually right but never guaranteed. It teaches you to design around that fact.
You should be able to read JSON and short pseudocode, and you should have called an HTTP API. You should also know what a retry and a timeout are. The course defines every other term where it first appears. Nothing else is assumed.
What This Course Is Not
The course teaches patterns, not a framework. It does not depend on any framework or model vendor. Its code is short pseudocode, not a library that you install. One later lesson covers what a framework gives you and when to adopt one. An appendix collects the protocol details that change quickly.
The course also does not teach model training, fine tuning, or how to write instructions for a model in general. It covers the instructions only where their design affects how an agent behaves.
What the Course Covers
The course moves from one agent that works, to an agent you can trust, to systems of agents at scale, and ends with complete designs. In order, it covers these subjects:
| Subject | What you learn to decide |
|---|---|
| What an agent is and when to build one | Whether a task needs an agent, a fixed workflow, or one model call |
| Workflow patterns | How to chain, route, and check model calls in a fixed order |
| Tool use patterns | How to design tools that a model can call correctly and safely |
| Planning and reasoning patterns | How an agent plans, notices that it is stuck, and corrects itself |
| Context engineering patterns | What goes into each model call, and what to leave out |
| Human oversight patterns | Where a person must approve, and how to keep approvals meaningful |
| Reliability and guardrail patterns | How to block bad actions, verify results, and recover from failure |
| Security patterns | How to defend an agent against instructions hidden in the content it reads |
| Evaluation and observability patterns | How to measure an agent and debug a failed run |
| Memory patterns | What an agent should store, recall, and forget across runs |
| Multi agent patterns | When several agents work better than one, and how they coordinate |
| Cost, latency, and scale patterns | How to estimate and reduce what an agent costs and how long it takes |
| Interoperability and change | How agents connect to other systems, and how to keep a design portable |
| Full designs and the pattern catalog | Five complete agent designs, a blank brief to design yourself, and a reference of every pattern |
The map below groups these subjects into the four parts of the course.
Notice the order of the parts. An agent must first work, then it must be safe to trust, and only then is it worth running at scale. The full designs at the end use the patterns from all three earlier parts.
How Each Lesson Works
Most lessons teach one pattern in the same order. A lesson explains what the pattern does, shows how it works, works through one example, states what it costs, and says when a simpler design is better. That last section matters, because many agent problems are solved by doing less.
The examples use four agents that return throughout the course:
| Agent | What it does |
|---|---|
| Desk | Answers customer support cases for an online store, including refunds |
| Forge | Makes changes to a code repository and runs its tests |
| Mailbox | Manages one person's email, with access to the web |
| Scout | Researches a question and writes a report |
Many lessons include arithmetic, such as how many tokens a run sends or how often a run of ten steps succeeds. The numbers start from stated assumptions, so you can repeat the calculation for your own system before you build it.
How to Practice
Each lesson ends with four practice questions, and each answer is folded so that you can try the question first. Each chapter ends with an adaptive assessment that draws a new set of questions on every attempt. The course closes with a final exam across all chapters, and a capstone that asks you to produce a complete agent design from a blank brief.
Read the chapters in order the first time, because later lessons use the terms and the running examples that earlier lessons define. After that, the pattern catalog at the end serves as a reference that you can return to.
The course starts with the most basic decision of all, which is how much control to give the model. The first lesson, The Autonomy Spectrum, compares a single model call, a fixed workflow, a single agent, and several agents working together.
Reading Progress
0%
On This Page
Who This Course Is For
What You Need Before You Start
What This Course Is Not
What the Course Covers
How Each Lesson Works
How to Practice