The Commons · Study guide
Self-Improving
AI Agents.
Stanford's CS329A is a graduate seminar on how AI systems get better at hard tasks: by thinking longer, checking their own work, using tools, and learning from what worked. The lectures and the full reading list are online for free.
This page is our map of the course: what each block is about, in plain language, and which paper to open first. It is an independent student summary. We are not affiliated with Stanford, and all course material belongs to its instructors, Aakanksha Chowdhery and Azalia Mirhoseini.
Why we recommend it
You do not need to train models to use this.
Most of the progress in AI right now is not bigger models. It is better systems around them: more attempts, a checker, a plan, a memory. Once you see those parts, you can tell which tools will hold up on real work and which only look good in a demo. That is the judgement our club is about.
The course is technical. You will not follow every equation, and you do not need to. Watch the lectures for the ideas, read the abstracts, and use the questions under each block below.
How to use it
Three ways in.
- One evening
Watch Part 1, the course overview, then read the "In plain terms" lines on this page. You will have the vocabulary.
- One week
Pick three blocks below. For each, watch the matching lecture and read the abstract of the first paper listed.
- The whole course
Follow the schedule on the course site, lecture by lecture. Bring a friend. It is far easier to finish with someone.
The nine core lectures are the Autumn 2025 recordings, published by Stanford Online. They follow the same order as the blocks below, and each block links its lecture. Guest talks are at the bottom of this page.
The concepts
Ten blocks, in course order.
Each block: what it means, why it matters if you use these tools rather than build them, and where to start reading.
01
Test-time compute
Watch: Part 2 · Test-Time Compute Scaling ↗(opens in a new tab)
In plain terms. Instead of asking a model once, let it try many times, or think longer, and keep the best result. On many problems, the share solved keeps rising as you add attempts.
Why it matters. "Think harder" modes and reasoning models are this idea. Spending more compute on a question can matter as much as picking a bigger model.
Ask yourself: when is a second or tenth attempt worth paying for?
02
Verification
Watch: Part 3 · Robust Verification ↗(opens in a new tab)
In plain terms. Many attempts only help if something can tell the good answers from the bad ones. A verifier is that checker. It can score the final answer, or every step on the way.
Why it matters. Generating is cheap; knowing what is correct is the bottleneck. This is the research version of "never trust an output you cannot check".
Ask yourself: what is the verifier in my own workflow, and is it me?
03
Learning from feedback, tools and code
Watch: Part 4 · Learning from Feedback with Tools/Code ↗(opens in a new tab)
In plain terms. An agent alternates between reasoning and acting: it searches, runs code, reads the result, and adjusts. Feedback can come from the world (did the code run?) or from written principles the model critiques itself against.
Why it matters. This loop is what separates an agent from a chatbot. It is also where most real-world failures happen.
Ask yourself: what feedback does the tool actually see before it answers me?
04
Planning and multi-step reasoning
Watch: Part 5 · Planning and Multi-Step Reasoning ↗(opens in a new tab)
In plain terms. Long tasks break when an agent commits to its first idea. These methods let it explore several paths, back up, or split a task into smaller ones only when it gets stuck.
Why it matters. Most business work is multi-step. How an agent plans decides whether it finishes or drifts.
Ask yourself: would I give this task to a person as one instruction, or as five?
05
Training with reinforcement learning
Watch: Part 6 · Train Time Scaling/Scaling RL ↗(opens in a new tab)
In plain terms. A model generates its own solutions, keeps or rewards the ones that turn out correct, and trains on them. Repeat, and it improves on its own output.
Why it matters. This is how today's reasoning models were built. It works best where answers can be checked, like maths and code, which explains where they are strongest.
Ask yourself: is my task one where "correct" is easy to check?
06
Open-ended self-improvement
Watch: Guest talk · Jeff Clune, Open-ended Agent Learning ↗(opens in a new tab)
In plain terms. Systems that design agents, run experiments, or improve algorithms, keep what works, and build on it. Here the agent is improving the process, not only the answer.
Why it matters. This is the frontier the course is named after. It is useful for telling real progress apart from announcements.
Ask yourself: who checks the work when the system writes its own next version?
07
Search and deep research agents
Watch: Part 7 · Self-Improvement and Deep Research Agents ↗(opens in a new tab)
In plain terms. Generate a large number of candidates, filter them hard, and pull in outside information while reasoning instead of relying on memory alone.
Why it matters. "Deep research" features work this way. Knowing it tells you to check the sources, not only the summary.
Ask yourself: which claims in this report did I open the source for?
08
Agents for software engineering
Watch: Guest talk · Michele Catasta, Coding Agents ↗(opens in a new tab)
In plain terms. Coding is where agents are furthest along, because code can be run and tested. These papers show how agents fix real repositories and speed up programs.
Why it matters. What works in code today tends to show up in other knowledge work later. Watch this space to see what is coming.
Ask yourself: what would the "test suite" be for my kind of work?
09
Memory
In plain terms. A model can only look at so much at once. Memory systems decide what to keep, what to page out, and what to bring back, a bit like an operating system managing RAM.
Why it matters. Long projects fail when the tool forgets early decisions. Good memory is the difference between an assistant and a colleague.
Ask yourself: what context does the tool need that it cannot see right now?
10
Evaluation and long tasks
Watch: Part 8 · Agentic Evaluations and Long Horizon Tasks ↗(opens in a new tab)
In plain terms. How do you measure whether an agent can do real work? One answer: measure how long a task, in human hours, it can finish reliably. Another: grade it on actual work products from real occupations.
Why it matters. Benchmarks are how vendors sell. These papers teach you which numbers mean something.
Ask yourself: how would I test this tool on my own work before trusting it?
Paper titles are shortened in places. Links go to arXiv or the authors' own PDF; the full list, with readings we left out, is on the course site.
Guest lectures
The people building it.
The course invites people who build these systems. The guest talks are not in the core series above; these recordings are from the Winter 2025 run, uploaded by the instructor.
Done with all nine? Part 9 · Future Research Areas ↗(opens in a new tab)