AI Agents Lecture Slides: Three Open Lectures With Instructor Notes

The AI agents lecture slides in this site’s teaching kit are three decks for the first three weeks of a thirteen-week course. Each is an HTML deck with presenter notes on every slide, plus a PDF without notes, linked from the teaching kit. They are licensed CC BY 4.0: reuse, adapt and translate them with attribution.

This page is the reference for those three decks. I wrote the decks, so I have tried to state the limits as plainly as the contents.

What do the AI agents lecture slides contain?

The three decks cover weeks 1 to 3 of the syllabus, each planned for 80 minutes, each with one in-class activity built on a browser tool and one piece of out-of-class work plus a short reading quiz. Every number in the table is stated in the lecture’s own notes file.

Two things in that table differ from what the titles might suggest. There is no separate deck on the language model and no separate deck on the loop. The model takes the second half of lecture 1 and the first half of lecture 2, and the loop is the second half of lecture 2.

Only the Preface, Chapters 1 and 2 and the glossary are free online. Lecture 1’s reading is entirely free. Lecture 2’s is free for the Chapter 2 sections and in the full book for Chapter 3 and Appendix A. Lecture 3’s is in the full book.

Each deck prints this on its section slides, which read “(free)” or “(full book)”.

These AI agents lecture slides need no paid model API. The in-class tools run in a browser with no account and no API key. Lecture 1’s homework allows “any model you can reach for free”, and both labs replace the model with a script.

Where are the files, and how do the notes work?

Each lecture has one page with two buttons, “Open the slides” and “PDF”, and the instructor notes sit on that same page. The addresses follow the week number.

The pages are lecture 1, lecture 2 and lecture 3.

How are the presenter notes shown?

Presenter notes appear when you press N in the HTML deck; F toggles fullscreen. Every slide has notes: 28, 28 and 29 of them. Adding ?notes to the deck’s address opens it with the notes panel already visible, and a slide number after # is a deep link, so deck.html#15 opens slide 15.

The PDF is the same deck with one slide per page and without notes. Lecture 1’s notes file describes it as meant “for handouts and for instructors who present from a PDF viewer”. If you present from the PDF, read the notes in the HTML deck beforehand, because they are nowhere in the PDF.

There is no slide-software file. The AI agents lecture slides exist as HTML pages and PDFs only, so editing a slide means editing HTML, or rebuilding the slide in your own tool with the attribution line attached.

What is on the lecture page besides the deck?

The lecture page holds the second kind of notes: prose written for the instructor. Each one has a section on how to run the session, the timing table, common misconceptions with a response to each, materials, and the exercises with acceptance criteria.

A commenter on Hacker News put the distinction this way: “The things that make for useful notes are very different from the things that make for good visual aids” (stevenbedrick, 9 October 2010). The slides here are visual aids. The presenter notes and the lecture page are the notes.

Lecture 1: what an agent is, and the engine underneath

Lecture 1 fixes the course vocabulary in its first half and explains how a language model produces text in its second. The first half follows Chapter 1 through the working definition of an agent, the chatbot, workflow and agent distinction, and the four compass bearings. The second half follows the first three sections of Chapter 2.

The notes file gives this plan, which I reproduce as printed:

The file also gives two variants. For 90 minutes, the exercise gets 20 and the other five go to slide 15, with students computing the table rows themselves. For 75 minutes, the debrief is shortened and slides 11 and 12 are merged into one pass.

What does lecture 1 assume?

This is my reading of the slides; the lecture file lists no prerequisites. No slide in lecture 1 carries code. Students need to know what a control-flow diagram is, because slides 9 and 10 turn on who decides what happens next. They need to raise a number to a power for slide 15, which works 0.95²⁰ as a labeled illustration.

Nothing in the deck expects a student to have called a model API or studied machine learning. The homework needs access to some free chat interface or a local open-weight model, which the file names only as categories.

Which misconceptions and activity does lecture 1 prepare?

The notes list six misconceptions with a response to each. Three of them: “An agent is any app with an LLM in it”, “The model remembers our earlier chats”, and “Temperature zero makes the output deterministic”.

Three slides are built to be answered by the room before you advance: slide 8, slide 20 and slide 24.

In the activity, pairs write three requests from their own work or studies and run each through the Should this be an agent? browser tool. They submit the tool’s Markdown export plus two lines per request: who owns the control flow, and what signal would tell them it worked. The notes also name a short explainer, What is an agent?, to play before the exercise or assign beforehand. The 80-minute table has no slot for it.

Lecture 2: the engine’s failure modes and the loop

Lecture 2 finishes Chapter 2 in its first half and teaches the loop in its second. The first half covers prompting in one slide, structured output and constrained decoding, function calling, six failure modes and compounding error with its three levers. The second half covers the loop, ReAct, the four parts of a minimal agent inside a harness, and the three exits.

For 90 minutes, the file plays the three-minute agent loop explainer on slide 17 and gives the rest to slide 18, tracing the chapter’s seven-pass checkout run on the board. For 75 minutes, it skips slide 5 and takes slide 25 as a one-line answer.

The split in the reading falls exactly at slide 16, the section slide marked “Part 2 · Chapter 3 and Appendix A (full book)”. An instructor without the book still has a complete deck with presenter notes for slides 16 to 28. The reading behind those slides is in the full book. For background on that half, the post on what an agent loop is explains the concept on its own.

What does lecture 2 assume?

Again, this is my reading. Lecture 2 assumes lecture 1: its opening segment is called “the bridge from week 1”. Four slides carry pseudocode or a schema: slide 9 (a tool definition), slide 18 (the loop on an index card), slide 21 (the execute function) and slide 24 (the lab’s scripted client). A student has to read a function definition, a list and a nested record.

Slide 6 asks students to sketch a parser, so they need to have written one small program. Slides 13 and 14 need independent events and a root: the exercise’s first answer is the twentieth root of 0.9, about 99.47%. Lab 1 asks for tests that pass with the machine offline, which presumes some unit-testing practice.

Which misconceptions and activity does lecture 2 prepare?

The notes list eight misconceptions. Three of them: “The model runs the tool”, “Structured output means the answer is correct”, and “Real agents need a framework”. Four slides are built to be answered first: 6, 8, 20 and 22. The notes also ask you to work slides 13 and 14 on the board.

The activity opens with the Why errors compound explainer, about three minutes. Pairs then answer four questions with the compounding-error calculator and submit its Markdown export with at most half a page of answers. Lab 1 has students type in Appendix A’s program in a language of their choice and swap the provider call for a scripted model client. It includes two tests that break the loop on purpose.

Lecture 3: planning, tools and the action space

Lecture 3 covers Chapter 4 in its first half and Chapter 5 in its second: how a goal becomes steps, whether a model can catch its own mistakes, and how to design the tools an agent acts through. Both chapters are in the full book. The notes file says the slides quote the chapters verbatim where it matters, so that students without the book can still follow the lecture.

The file is candid that the exercise is the tightest segment: 20 minutes leaves about 13 for the work and 7 for the debrief. With 85 minutes or more, the exercise gets the extra five first. For 75 minutes, the exercise drops to 17 and slides 25 and 26 take two minutes together. For 90 minutes, the exercise gets 30 and one team presents its whole redesigned set.

Slide 14 carries the sentence the first half builds to, from Chapter 4: “A real verifier beats the model grading itself.”

What does lecture 3 assume?

My reading once more. The notes refer back to week 1’s litmus test and to Chapter 3, so lecture 3 assumes both earlier lectures. Slide 2 opens on migrating a service off a deprecated payments API, and slide 18 asks whether wrapping three calendar endpoints would work. A student who has never called an API will need both examples explained.

Slide 21 shows an error as a JSON object, and the exercise hands teams seven tool definitions written as JSON with an input schema. Lab 2 begins “Extend your Lab 1 agent”, so it cannot be set on its own.

Which misconceptions and activity does lecture 3 prepare?

The notes list eight misconceptions. Three of them: “More planning is always safer”, “Asking the model to double-check its work catches errors”, and “A clean lint means a good tool”. Four slides are built to be answered first: 2, 8, 11 and 18.

In the activity, teams of three open seven deliberately flawed tool definitions in the tool-contract linter, fix the findings, look for two flaws the linter missed, and re-lint. They submit the fixed JSON, the linter’s Markdown export and a short note. The lecture page includes an instructor key with one redesign of the seven tools.

This lecture asks one thing of you before class. Have the handout of seven definitions printed or posted, and check that the link on slide 24 opens the linter with the set loaded.

How would I adapt each lecture to the room?

The table below is my own advice, and the lecture files contain none of it. They give slot variants and misconceptions and say nothing about cohorts. I cite no study for these rows and claim no outcome. Each row moves minutes between real segments, and the arithmetic is shown so you can check it.

• CS majors without ML are the students the syllabus prerequisites describe: programming, introductory probability, ordinary software practice.
• Mixed engineering means a room drawn from several engineering programs, where I assume probability is comfortable and JSON or unit tests less so.
• Working professionals in an evening class write software for a living and bring real tasks.
• A 50-minute slot fits none of the lectures, so each one is split across two sittings.

Some of these moves come from the files’ own variants: merging slides 11 and 12, skipping slide 5, taking slide 25 in one line, compressing slides 25 and 26, extending the exercises of lectures 1 and 3, and lecture 2’s explainer and traced run. The minutes I assign to each move are mine. The explainer in lecture 1 runs about three and a half minutes by the file’s account, and I budget four.

I attach no attention-span rule to these splits. The longest single segment of lecture in the three timing tables is 14 minutes (lecture 1, slides 8 to 12). A review of the literature by Bradbury, of which I read the abstract only, concluded that “the available primary data do not support the concept of a 10- to 15-min attention limit” (Bradbury, 2016).

For the wider question of who such a course suits and why it avoids a single vendor, see the companion post on teaching AI agents to computer science students.

What line do you print when you reuse the slides?

The kit names one attribution line for these AI agents lecture slides, and CC BY 4.0 asks for three things around it. The license deed says: “You must give appropriate credit, provide a link to the license, and indicate if changes were made.” It also says you may do so in any reasonable manner, as long as the manner does not suggest the licensor endorses you or your use.

The deed permits copying and redistributing the material “in any medium or format for any purpose, even commercially”, and adapting it on the same terms. CC BY 4.0 carries no non-commercial and no share-alike condition.

This is the kit’s own line, as the hub prints it:

From the teaching kit of AI Agents, Engineered by Enrique Gutiérrez, CC BY 4.0, aiagentsengineered.com/teach/

The end slide of each deck carries the same words, opening “Slides from the teaching kit”, and prints the license address, creativecommons.org/licenses/by/4.0/, on the line below. If you present an unmodified deck, the line and the link are already on it. If you paste the line somewhere else, add the link to the license yourself.

For slides you have changed, the line needs a changes note. No file in the kit prints an adapted variant, so the wording below is this post’s suggestion:

Adapted from the teaching kit of AI Agents, Engineered by Enrique Gutiérrez, CC BY 4.0, aiagentsengineered.com/teach/. Changes: [say what you changed, for example "slides 5 and 25 removed; examples replaced"]. License: https://creativecommons.org/licenses/by/4.0/

People who reuse slides ask for this clarity. One forum poster, facing a slide notice that named two different sets of terms, wrote: “Can we get some clarification on what is the intended license?” (ixfd64, 4 March 2024). An issue on a university course repository asked for “organization, course, author names and license footer on each slide” (hmitaso, 30 September 2019).

The deed describes itself as a highlight of the license with no legal value of its own. The legal code is the license. Nothing here is legal advice.

What should you do the week before you teach?

Open the deck with its notes, run the activity once, settle the reading, and place the attribution line.

How do the three lectures fit the thirteen-week syllabus?

The three lectures are weeks 1, 2 and 3 of a thirteen-week syllabus, with the same titles the syllabus gives those weeks. Weeks 4 to 13 each have a syllabus entry and no deck. I give no date for them here.

Of the eight labs the syllabus plans, two have handouts so far: Lab 1 with lecture 2 and Lab 2 with lecture 3.

A six-week professional short course is also mentioned in the syllabus, built from weeks 1, 2, 7, 8, 9 and 11. Only the first two of those weeks have decks at the time of writing.

For the reasoning behind the week order, see the post on the AI agents course syllabus, which covers sequencing and assessment. The dependency argument, topic by topic, is in the post on an agentic AI curriculum.

What are the limits of this kit?

As AI agents lecture slides go, this set is small: three weeks of thirteen, with several things an instructor might expect still absent.

• Three of thirteen. Ten weeks have a plan and no deck.
• No notes in the PDF. Presenter notes exist only in the HTML deck.
• No slide-software file. Editing means HTML, or rebuilding slides in your own tool.
• Reading after week 1 is mostly in the full book. Week 2’s is partly free: Chapter 3 and Appendix A are in the full book. Week 3’s, Chapters 4 and 5, is all in the full book.
• Timings are a plan. The files report no classroom trial. Lecture 3’s notes say its exercise was first timed with five more minutes than the 80-minute plan gives it.
• The cohort advice is one author’s judgment. The files give no per-lecture prerequisites.

Where to go next

Start with lecture 1, because everything it uses is free to read: the Preface, Chapter 1, “What Is an Agent?” and the first three sections of Chapter 2. Open the deck, press N, and judge the notes for yourself. Chapter 3, “The Agent Loop” supplies the second half of lecture 2 and is in the full book; you can see the formats on the home page.