AI Agents Mastery Path¶
An AI agent is a loop: a language model looks at what it knows, proposes an action — call a tool, search, write a file, ask a human — your code carries it out, and the result goes back to the model for the next decision. That loop is simple to write and surprisingly hard to make reliable, affordable and safe. This course teaches both halves: how to build agents, and how to engineer them so they can be trusted with real work.
It starts from first principles. In Level 1 you write a complete agent in plain Python with no framework and no API key — a mock model stands in for the LLM so every example runs offline and prints real, reproducible output. Once you have written the loop yourself, frameworks such as LangChain and LangGraph stop being magic: Level 2 maps each of their concepts onto code you already understand, then adds state graphs, memory, planning patterns, retrieval as a tool, human approvals and streaming. Level 3 is about scale and rigour — multi-agent supervisors and handoffs, the Model Context Protocol, sandboxed code execution, evaluating agents by outcome and by trajectory, cost and latency, retries and idempotency, and defending against prompt injection that arrives through tools and data. Level 4 is production: architecture, observability, least privilege, policy as code, enterprise workflows, testing, ethics and accountability, rollout and incident response — and an honest lesson on when not to build an agent.
Every lesson has a How It Actually Works section explaining the mechanism behind the practice: why appending a tool result makes the model use it, why error messages are really prompt content, why a checkpoint lets a paused run resume in another process, why prompt caching needs a byte-identical prefix, why controls must live outside the model.
Vendor-neutral, runnable, and honest about outputs
The code uses only the Python standard library and a mock model, so it runs on any machine without keys or cost. Output shown under each script is real output from running it. Framework snippets (LangGraph and similar) are short, marked as not executed here, and describe the shape of an API that changes between versions — always check current documentation. The course never presents a model response as a recorded output, and never quotes benchmark numbers it cannot reproduce.
How the program is organized¶
| Level | Focus | Modules |
|---|---|---|
| Level 1 · Entry | Agents vs chatbots & workflows, the agent loop, tool calling, tool design, a from-scratch agent, tool errors, stopping conditions, structured output, tracing | 9 topics + 1 project (a sandboxed file-organizer agent) |
| Level 2 · Intermediate | Frameworks & when to use one, state graphs, short- and long-term memory, ReAct & plan-and-execute, reflection, retrieval as a tool, approvals, streaming | 9 topics + 1 project (a research agent with approvals) |
| Level 3 · Advanced | Multi-agent systems, supervisors & handoffs, MCP, sandboxing, task-success and trajectory evals, cost & latency, reliability, prompt-injection defense | 9 topics + 1 project (an evaluated multi-agent triage system) |
| Level 4 · Master | Production architecture, observability, least privilege, policy as code, enterprise workflows, when not to use agents, testing, ethics, rollout & incidents | 9 topics + 1 capstone (a production-ready governed agent) |
How to use this site¶
- Build one project folder as you go. Code blocks titled with a file name
(
mini_agent.py,tools.py,guards.py...) are meant to be saved together; later lessons import earlier files, just as a real codebase grows. - Run everything, then break it. Each lesson's mock model can be edited to misbehave — call the wrong tool, loop, ignore a denial. Watching your controls catch it teaches more than any diagram.
- Swap in a real model when you're ready. Level 1 lesson 05 shows the single adapter function to replace; nothing else in the loop changes.
- Do the Exercise at the end of each lesson; the module-10 projects build on them.
- Related courses: agents sit on top of several other skills. For calling LLM APIs, streaming and serving, see LLM Dev Mastery Path; for building the search indexes agents query, see RAG Mastery Path; for writing the prompts inside an agent, see Prompt Engineering Mastery Path; for choosing and adopting AI tools as an organisation, see AI Tools Mastery Path and Claude Training Mastery Path. This course links to those instead of re-teaching them and stays focused on the agent: the loop, its tools, and the engineering around it.
Start here → Level 1 · Entry
🎥 Prefer video? Watch the Mastery Path video series on YouTube — Shorts and full walkthroughs of lessons across the series.
More from the Mastery Path series¶
Free, structured, module-wise training across 71 other languages, platforms and disciplines:
Languages
Web Frameworks
Testing & QA
Security
Cloud Platforms
Data & Analytics
AI / ML / LLM
Embedded Systems
Leadership & Management
Professional Skills
Careers & Interviews
Process & APIs
Infrastructure & Ops