Read this first

1. What this course is

This is a course on building autonomous AI agents — the kind that run in production, take real actions on a user's behalf, recover from failure, stay inside a cost budget, and don't quietly hallucinate their way through your customers' data.

Not "agents" in the LinkedIn-thought-leader sense. Not "agents" as the title of a Jupyter notebook with one while True: loop in it. Agents as in:

• A Python service.
• That calls an LLM.
• That calls tools.
• That remembers things across sessions.
• That fails into a human's lap when it shouldn't be deciding.
• That you can observe, evaluate, secure, and deploy.
• That you can explain, line by line, to a senior engineer who's never seen it.

If you can ship that, you can be hired as an AI agent engineer. That is the entire premise.

2. The thing the field has gotten wrong

The internet is drowning in agent tutorials. Most of them are five hundred lines of LangGraph that work on the recorded happy path and fail silently on everything else. The author shipped a YouTube video. The reader shipped nothing.

The tutorials skip the boring parts — and the boring parts are most of the job.

The boring parts are:

• Async correctness. Most "agents" leak file handles, race on shared state, and corrupt their own memory because the author never internalized asyncio.
• Token economics. Most agents cost 10× what they should because nobody routed cheap requests to a cheap model.
• Evals. Most agents have zero quality measurement. The author has no idea if the latest prompt change broke the 30% case that mattered.
• Tracing. Most agents have no observability. When something breaks in production, the author reads transcripts.
• Security. Most agents are wide open to prompt injection. The first hostile user owns the system.
• Deployment. Most agents have never run anywhere except the author's laptop. Concurrency, scaling, rollback — unsolved problems.

This course is mostly the boring parts. The boring parts are what separates the people who get hired from the people who keep watching tutorials.

3. Who this course is for

You, if:

• You can read and write Python at a working level. (async def, type hints, virtualenvs, FastAPI shouldn't terrify you. We'll teach the rest.)
• You've built at least one toy LLM thing — a chatbot, a RAG demo, a tool-calling script — and felt, honestly, that it was held together with hope.
• You want a job, a promotion, or a serious open-source presence as an AI agent engineer in 2026 or 2027.
• You're willing to actually write the seven capstone projects, push them to GitHub, and deploy them. (Not negotiable. The course doesn't work if you only read.)

You, if not:

• You've never written code. Start with Blank to Browser first. Come back when you can ship a small Python service.
• You want a course on prompt engineering with no code. That's Vibe to Spec. It's free.
• You want a survey of which AI library is the most popular this week. That's a blog, not a course.

4. What it is not

This is not a course on a specific library. LangGraph, CrewAI, AutoGen, OpenAI Agents SDK — they're all touched in the relevant stages, but the principles are framework-agnostic. If LangGraph rewrites its API tomorrow (it will), you'll still know what a supervisor is and why bounded iteration matters.

This is not a course on which LLM is best. The code uses provider-agnostic patterns. You can run the capstones on Anthropic, OpenAI, Google, Mistral, or a local model — whatever you have a key for or GPU under.

This is not a course on building general intelligence, AGI, ASI, or whatever the buzzword will be by the time you read this. It is a course on shipping software that uses a model as one component inside a system you can reason about.

5. The shape of the work

Twelve stages, in order. Each stage is one chapter. Each chapter is four to six units. Each unit follows the same four beats:

1. Principle. One durable idea, stated in plain language.
2. Do. Hands on the keyboard. Concrete code you run.
3. Verify. A test you run yourself. Pass-or-fail in under a minute. No grader needed.
4. Reference. The worked solution, plus the failure modes you should have hit on the way.

Seven of the units are capstones. A capstone is bigger: a full agent you build, deploy, and put on GitHub. The capstones are the seven projects you walk out with — they are the actual portfolio.

Capstone	After	What you ship
1	Ch 3	Toolbot — structured-output tool-calling research agent
2	Ch 4	Memo — memory-backed personal assistant
3	Ch 5	Scholar — ReAct deep-research agent with citations
4	Ch 6	Review Crew — multi-agent code-review supervisor pattern
5	Ch 8	Eval Harness — automated quality measurement for any agent
6	Ch 10	Hardened Support Agent — production-grade, secured
7	Ch 12	Portfolio Drop — your own agent, deployed and documented

6. The honest test

The next unit is the map: how the twelve stages connect, what skill each one installs, and which one you should jump to if you already know parts of this.

7. Try it

If the gap between what you can do and what you want to do feels uncomfortable — good. That gap is what the next twelve chapters close.