The course guide
Prerequisites, practical setup, topic coverage, and the primary sources behind your work.
Start here
This course is built for a software engineer or data scientist who wants to understand how agent systems work, implement the mechanisms, and create a portfolio backed by evidence. Basic programming helps; the first phase builds the mathematical and engineering foundations you need.
- Begin with module 1. If a topic is familiar, solve its lab without hints before skipping ahead.
- Read each lesson, trace its code, answer the reasoning exercise, and take the knowledge check. Save a short explanation in your own words.
- Implement the module lab. Tests cover concrete behaviors; inspect and extend them rather than treating a green result as complete understanding.
- Build the mini project from its running seed. Satisfy the acceptance criteria and document at least one failure case.
- Choose one capstone. Read related work, establish baselines, and evaluate a falsifiable claim. Record your actual results.
All lessons are available from the start. Your progress, notes, answers, selected capstone, and saved lab drafts are associated with your signed-in account.
Set up a local engineering workspace
In-browser labs use Python 3.12 and the standard library. They need no provider account or API key. For projects, install Python 3.12+ and Git, download a starter, and read its README before running it.
python -m venv .venv
# macOS / Linux
source .venv/bin/activate
# Windows PowerShell
# .venv\Scripts\Activate.ps1
python main.py
# For an exported lab with embedded checks
python lab01.pyThe full companion contains the original lessons, lab starters and checks, reference solutions, project seeds, and capstone blueprints. For the web course, you only need a recent browser with WebAssembly and Web Workers enabled.
When a lesson needs more than your laptop
All coding challenges and supplied project seeds run without a GPU or model API. Lessons that show actual provider SDKs name the required packages and configuration. Live API requests can incur provider charges. Full fine-tuning or large-model serving may require additional hardware; start with the small simulations and calculation exercises first.
Keep real API keys in local environment variables or a server-side secret manager. Never put them in the browser lab editor, a public repository, or a screenshot.
What each code block means
Deterministic examples include expected outputs. Provider responses and external integrations label their output as illustrative. Protocol and security simulations teach individual mechanisms; they do not claim complete production conformance or isolation.
Build portfolio evidence, not just features
- A clear problem statement and a small, reproducible dataset.
- An architecture diagram with explicit trust boundaries and failure behavior.
- A baseline, a proposed improvement, and a comparison on the same held-out cases.
- Costs, latency distributions, errors, and limitations alongside task success.
- A one-command demo, tests, a short narrated walkthrough, and a failure analysis.
- A resume bullet with measured outcomes, including the dataset size and baseline.
No novelty or employment outcome is guaranteed. A focused, carefully evaluated project is easier to defend than a broad demo with untested claims.
Topic coverage, at a glance
| Topic family | Your modules |
|---|---|
| Attention and transformer foundations | 02 · 03 · 04 |
| Model internals and model selection | 04 · 05 · 29 |
| Developer foundations and a first agent | 01 · 05 · 06 |
| MCP interoperability | 07 · 08 |
| Structured reasoning and planning | 09 · 10 |
| Cognitive architecture and adaptive decisions | 06 · 10 · 21 |
| Memory and retrieval | 11 · 12 · 13 |
| Multi-agent coordination and DAGs | 14 · 26 |
| Browser automation and research | 15 |
| Desktop control and multimodal perception | 16 |
| Channel gateways and voice | 17 |
| Recovery, isolation, and security | 21 · 22 · 30 |
| Agent-to-agent interoperability | 18 |
| Declarative and event-driven agent interfaces | 19 |
| Routing, costs, and observability | 23 · 29 |
| Proactive, event-driven systems | 20 |
| Coding agents and versioned skills | 25 |
| Evaluation and benchmarking | 24 · 31 |
| Complete system integration | 26 · 32 |
| Project proposals, experiments, and delivery | 31 · 32 |
| Additional depth: data, fine-tuning, and reinforcement learning | 27 · 28 |
| Additional depth: privacy and reproducible research | 30 · 31 |
Primary-source reading library
Technical references were checked on September 7, 2026. Protocol lessons identify the specification version they discuss. Check the linked official documentation when implementing a live integration.
01. Python at the system boundary
02. The mathematics of useful predictions
03. Neural computation from first principles
04. Inside a modern language model
05. Integrating models without losing control
06. Your first bounded agent service
07. Tool contracts that survive real requests
08. MCP integration with explicit version and trust boundaries
09. Observable planning and evidence-driven revision
10. Cognitive architecture as an inspectable control system
11. Memory with scope, provenance, and a lifecycle
12. Retrieval that preserves the evidence needed to answer
- Retrieval-Augmented Generation for Knowledge-Intensive NLP Tasks
- Dense Passage Retrieval for Open-Domain Question Answering
- The Probabilistic Relevance Framework: BM25 and Beyond
- Reciprocal Rank Fusion outperforms Condorcet and individual Rank Learning Methods
- Sentence-BERT: Sentence Embeddings using Siamese BERT-Networks
13. Advanced RAG with graphs, time, and evaluation
14. Collaboration with explicit dependencies
15. Browser agents with verifiable outcomes
16. Desktop perception and multimodal alignment
17. Channels, webhooks, and interruptible voice
18. A2A collaboration across service boundaries
19. Generated interfaces and streaming interaction
20. Event-driven and proactive agents
21. Recovery without duplicate actions
22. Permissions and containment for agent actions
23. Agent economics and observable performance
24. Evaluations that support engineering decisions
25. Coding agents that can justify their patches
26. Production agents as recoverable distributed services
27. Training data and efficient adaptation
28. Learning from rewards and preferences
29. Inference performance and capacity engineering
30. Privacy, adversarial evaluation, and operating boundaries
31. Research methods for agent systems
32. Integrated agent systems and capstone evidence
Extended reading and practice companion
Go further with a separate original companion: 100 additional lessons, 50 exercises, 25 runnable mini-project baselines, six capstone briefs with starters, and 200 recall cards. The 50 exercises are also available in Coding labs on this site. The main course keeps its 32-module sequence.
The companion has its own chapter numbering and README. Use it for alternative explanations, deeper practice, and additional project experiments. Baseline starters are starting points for your implementation and evaluation.
Runtime and licenses
The browser Python engine is Pyodide 0.27.7, distributed under the Mozilla Public License 2.0. Runtime files are hosted with the course. Source and component license information are provided in the runtime notice.