How This Course Works
One agent, built piece by piece
You do not build seventeen demos. You build one agent, BrightCart's Returns Desk agent, and every module gives it something it needs before it can be trusted to work unattended: tools, a loop, limits, memory, a sandbox, approval gates, evaluations, traces, a runtime, a way to roll back. By the end you have one repository you can show and explain line by line.
The project, its people, its dates and its rules are described in 03-the-returns-desk-agent.md. It is fictional; the real cases that open each lesson are not.
What you should already know
Python, calling a language model, prompting, structured output and basic retrieval. Module 1 is a brisk check of these, not a first course. If most of it is unfamiliar, take the AI Engineering course first: Module 7 (LLM Engineering) for model calls and structured output, Module 8 (RAG) for retrieval. Each module README here starts with What you need first, so you can check whether it is safe to jump ahead.
Pictures first
Every lesson is a walk through one example, one picture at a time. A figure shows an idea; a short paragraph says what the figure shows in plain words; a short block of code proves it; a walkthrough explains every line of that code. Then the next figure. A lesson has fifteen to thirty figures and takes forty to seventy-five minutes to read properly; each module README gives the time.
The same colours mean the same things in every figure:
| Colour | Means |
|---|---|
| Blue | Your system, the normal path |
| Amber | The model, anything uncertain |
| Green | Correct, safe, passed |
| Red | Failure, attack, danger |
| Grey | Optional, background, ignored |
The shape of every lesson
| Part | What happens | Why it is there |
|---|---|---|
| The situation | A specific moment in the project, with named people | You learn the idea because you need it |
| A real case, first | Something that really happened, from a published source, cited | So you know the idea matters outside a course |
| The idea | Figures and short paragraphs, one running example throughout | The picture comes before the vocabulary |
| Run it | Code you paste into Colab, with a code walkthrough | You see it work, and you understand every line |
| Break it | You make it fail on purpose | An agent's failures should not surprise you in production |
| In production | Cost, scale, and what goes wrong when nobody is watching | The part most courses leave out |
| Check yourself | Three to five questions, answers hidden until you click | You find out whether it stuck |
| Exercise | One task with a runnable check | You do it, not just read it |
| Key terms and sources | A short glossary and the sources the lesson used | So you can go further |
Three depths of topic
Each topic is marked in its heading:
| Mark | Meaning | What you get |
|---|---|---|
| (Essential) | You cannot do the job without it | Figures, code and a "break it" step |
| (Recommended) | Skip it only if you have a reason | A figure and a short section, often with code |
| (Optional) | Knowing it exists is enough | An "awareness card": what it is, when you would need it |
If you are short of time, do the Essential sections of every module first and come back for the rest.
How the course teaches agents
- By hand first, then the framework. You write the loop, a tool call, a checkpoint and a trace yourself in plain Python. Then you see the same thing in LangChain and LangGraph. You will know what the framework does for you.
- Scripted models where it matters. A real model will not loop forever or obey a hidden instruction on demand. When a lesson needs one exact misbehaviour, it uses a scripted stand-in so you see the same thing every time, and it says what a real model usually does.
- The model proposes, code decides. Limits, permissions and approvals live in code and in BrightCart's systems, never only in a prompt.
- Everything the agent reads is data. Customer messages, tool results, files, web pages and memories can carry instructions. One request in the test queue does, on purpose.
What every module contains
| File | What it is |
|---|---|
README.md | What the module is for, what you need to know first, the lesson list |
| Numbered lessons | One file per group of topics |
...-module-lab.md | A guided build that adds this module's piece to the agent, ending with a runnable check |
...-incident-file.md | A real, published agent failure, then the same failure replayed on the returns desk and fixed |
Labs run top to bottom in one fresh Colab notebook. Module 11's lab ends with a written decision, generated by code from measured runs.
Incident files start with a documented failure from outside, cited: a post-mortem, a security write-up, a bug report. They explain why it happened, replay it on the returns desk, and show the fix and how you would have caught it earlier.
How to run the code
All code runs in Google Colab. Open a new notebook, paste each code block into a cell in order, and run it. No installation is needed.
Every lesson that calls a model starts with the same short setup cell. It lets you choose between three model providers by changing one word. Groq and Gemini work in Colab with a free key. Ollama runs a model on your own computer, so if you choose it you work in a code editor on your machine. Setup for both routes, and how to run the whole project locally: 02-setup-colab-and-llm-providers.md.
BrightCart's order, returns, payment and email systems are played by a small simulator, so the agent has something real to act on without any accounts or servers. Lessons paste only the slice of data they need, copied from 06-shared-data.md. All of it is simulated.
Some topics cannot run in a notebook: container sandboxes, browsers, queues, a cloud deployment. Those lessons give exact instructions for your own computer, say plainly that they were not run in the course, and say what was checked against the official documentation instead.
The tools
Everything in the course is open source, apart from the hosted model services, which are shown as options. Phoenix, one of the trace viewers shown, is source-available (Elastic License 2.0), not open source. LangChain calls models and tools, LangGraph runs loops with state, checkpoints and approvals, and the Model Context Protocol (MCP), through its official Python SDK, connects the agent to outside systems. Closed models and hosted products are shown as short examples from their own documentation, labelled "not run here".
Fast-moving parts
Agent frameworks, MCP, sandboxing products and tracing tools change month to month. Every statement about them is dated, and the lesson says what is likely to change. The MCP lessons follow the specification dated 2026-07-28, which removed the start-up handshake and protocol sessions that much older material online still describes.
Your results will not match ours exactly
Models do not return the same words, or always choose the same tool, twice. When a lesson shows output, yours may differ. Building something dependable on top of that is the skill this course teaches. Every number printed in a lesson came from running that lesson's code on the date shown.