Part 1 · Course guide

Agentic AI Engineer: The Complete Course

5 min read·13 Oct 2026

Systems that decide what to do next, act on the world, and keep going without you watching. Everything worth learning to build them, and to keep them from causing damage.

Across 17 modules you build one agent: BrightCart's Returns Desk agent, which works a queue of return and cancellation requests unattended. It reads each request, looks up the order, applies policy, creates the return and refunds the money, within limits that code enforces and with a person approving anything expensive or irreversible. BrightCart is fictional; every lesson also opens with a real, cited case.

Who this course is for

You know the AI engineer basics: Python, calling language models, prompting, structured output and retrieval. Module 1 is a quick check, not a first course.

You are...	Start at
New to building with language models	The AI Engineering course first: Module 7 (LLM Engineering) and Module 8 (RAG), then Module 1 here
An AI engineer who has built assistants and wants to build agents	Module 1 as a check, then Module 2
Already building agents, and they are unreliable or unsafe	Modules 5, 12 and 13
A backend engineer adding an agent to a product	Modules 3, 5, 12 and 15

Every module's README lists what you need to know before starting it, so you can check whether it is safe to skip the one before.

What you need first

Python: functions, classes, exceptions, and reading a stack trace.
Calling a language model from code, writing a prompt, and asking for structured output.
What embeddings and basic retrieval (RAG) are for.

If any of these is new, the AI Engineering course teaches them on the same fictional store, BrightCart, with the same customers and orders.

What you need

A Google account, to run code in Google Colab. Nothing to install.
One free API key, from Groq or Google Gemini, to use in Colab. Or no key at all, if you run a model on your own computer with Ollama and work in a code editor.
For a few lessons (container sandboxes, queues, deployment), your own computer. Those lessons say so.

Setup takes about ten minutes: course-guide/02-setup-colab-and-llm-providers.md.

The modules

#	Module	What the agent gains	Needs first
1	Prerequisites	A project skeleton and a check of the engineering and LLM basics	Python, model calls and basic retrieval (AI Engineering Modules 7 and 8); the course setup
2	Model Behaviour for Agents	A system prompt with a role, a scope, stopping conditions and an output contract	Module 1
3	Tool Design	Eight well-designed tools, with errors the model can act on	Modules 1 and 2
4	Model Context Protocol	Its tools served through an MCP server	Modules 1 and 3
5	The Agent Loop	A loop with step, time and cost limits, by hand and in LangGraph	Modules 2 and 3 (Module 4 useful, not required)
6	Planning and Decomposition	Plans, and checks that do not rely on its own word	Modules 1, 3 and 5
7	Context Engineering	Compaction and notes for long runs	Modules 1, 3 and 5
8	Memory and State	Checkpoints, resumable runs and a careful memory	Modules 1, 3 and 5
9	Retrieval for Agents	Search as a tool it calls repeatedly	Modules 1, 3 and 5 (Module 8 helps)
10	Environments and Execution	Sandboxed code execution and dry runs	Modules 1, 3 and 5 (Lesson 1)
11	Multi-Agent Systems	A decision about whether to split it, and how	Modules 1, 3 and 5
12	Safety, Permissions, Oversight	Approval gates, least privilege, an audit trail, a kill switch	Modules 1, 3 and 5; Module 4 Lesson 3; Module 10 Lesson 3
13	Evaluation	A trajectory eval suite that gates every change	Modules 3 and 5 (Module 12 recommended)
14	Observability and Debugging	Traces, cost per step and replay	Modules 1, 3, 5 and 13
15	Runtime and Infrastructure	A background job that survives a crash	Modules 1, 3, 5 and 8
16	Deployment and Operations	A rollback, a runbook and an on-call plan	Modules 1, 3 and 12 to 15
17	Professional Practice	A write-up with numbers and known limits	Modules 5, 12 and 13 (the final checklist covers the whole course)

How each lesson works

Every lesson is a walk through one returns desk example, one picture at a time:

The situation: a specific moment in the project.
A real case, first: something that really happened, from a published source, cited.
The idea: fifteen to thirty figures, one idea each, one running example.
Run it: code for Colab, with a walkthrough of every line.
Break it: you make it fail on purpose, then fix it.
In production: what it costs, and what goes wrong when nobody is watching.
Check yourself: questions, one exercise, key terms and sources.

Each module ends with a lab (a guided piece of the agent) and an incident file (a real, published failure replayed on the returns desk and fixed). More detail: course-guide/01-how-this-course-works.md.

The tools you will use

Python throughout. LangChain for model calls and tools, LangGraph for loops, state, checkpoints and approvals, and the Model Context Protocol (official Python SDK) for connecting the agent to outside systems. Each mechanism is built by hand first, so you know what the framework is doing. FastAPI, SQLite, Redis, Chroma or FAISS, Docker and OpenTelemetry where a lesson needs them. Everything is open source apart from the hosted model services. Phoenix, one of the trace viewers shown, is source-available (Elastic License 2.0), not open source.

Course guide

File	Read it when
01-how-this-course-works.md	Before your first lesson
02-setup-colab-and-llm-providers.md	Before you run any code
03-the-returns-desk-agent.md	To meet BrightCart, the people, the dates and the rules
06-shared-data.md	To see the data, tools and simulated systems every module reuses
04-style-guide.md	Only if you are writing or editing lessons
05-image-style-guide.md	Only if you are drawing the course figures

The one idea

An agent that succeeds 90% of the time and fails silently is worse than one that succeeds 70% of the time and stops loudly. Most of the engineering here is in the second number, not the first.