CS329A: Self-Improving AI Agents (Stanford)

Sources#

• CS329A Self-Improving AI Agents — Part 1: Course Overview
• CS329A Self-Improving AI Agents — Part 2: Test-Time Compute Scaling
• CS329A Self-Improving AI Agents — Part 3: Robust Verification
• CS329A Self-Improving AI Agents — Part 4: Learning from Feedback with Tools and Code
• CS329A Self-Improving AI Agents — Part 5: Planning and Multi-Step Reasoning
• CS329A Self-Improving AI Agents — Part 6: Train-Time Scaling and Scaling RL
• CS329A Self-Improving AI Agents — Part 7: Self-Improvement and Deep Research Agents
• CS329A Self-Improving AI Agents — Part 8: Agentic Evaluations and Long-Horizon Tasks
• CS329A Self-Improving AI Agents — Part 9: Future Research Areas

Summary#

CS329A — Self-Improving AI Agents is a Stanford CS graduate course taught by Azalia Mirhoseini (assistant professor, CS) and Aakanksha Chowdhery (adjunct professor; Reflection AI). The Autumn 2025 offering was its second; lectures were recorded 2025-09-22 onward and published to YouTube in August 2026, which is why every state-of-the-art claim in them reads a year behind the rest of this wiki. Treat the whole series as practitioner-opinion dated late 2025 — useful as a dated baseline for how the field looked before the 2026 sources here, and as the teaching-grade statement of theses the wiki otherwise holds only in research-paper form.

The course's own framing of what makes it a course rather than an LLM survey: chatbots and reasoning models are still single-turn — "they're fun to interact with, but they're not necessarily accomplishing a task for you" — and agents are what close the loop from goal to completed work. The self-improving part is the flywheel the instructors name explicitly: test-time scaling produces verified trajectories, those trajectories become fine-tuning data, the better model then scales further at test time. "There's no boundary in how good the models can become with test time scaling and then bringing that back to the process of training the model."

The lecture-1 arc#

Lecture 1 is a compressed history of how the field arrived at agents, in six moves:

1. Scaling laws — test loss falls smoothly in compute, data, and parameters; the parameter curve from BERT (340M) → GPT-2 (1.5B) → GPT-3 (175B) → PaLM (540B) → GPT-4 ("estimated… trillions"), with the caveat that pure parameter scaling "was starting to hit some kind of a saturation point" around 2024.
2. Few-shot and emergence — zero-/few-shot prompting removes the per-task fine-tune; some capabilities (modular arithmetic, word unscrambling) appear only above a size threshold rather than improving smoothly.
3. Chain of thought — the canonical emergent behavior, and the one the instructors say "is holding to this day": below a size threshold, worked-reasoning exemplars do nothing for LaMDA/GPT/PaLM; above it, they help. (The transcript's specific parameter thresholds are ASR-garbled and are not quoted here.)
4. ChatGPT's actual delta — not scale, but the post-training stack: high-quality-data SFT → instruction tuning (human templates plus synthetic, including chain-of-thought fine-tuning) → RLHF, where a reward model trained on human preference pairs replaces the human in the loop and can be decomposed into weighted axes (correctness, helpfulness, specificity, harmlessness). See Alignment Fine-Tuning (AFT). ChatGPT launched Nov 2022 and reached 1M users in 5 days.
5. Inference as the third frontier — Mirhoseini's Large Language Monkeys result (Latent Capability Overhang), then o1/DeepSeek converting sampling coverage into pass@1 (Large-Scale Test-Time Compute).
6. From chatbots to agents — goal → plan → act on an environment → read feedback → correct → stop (or report failure), plus tools and memory. The named workflow patterns are Anthropic's Building Effective Agents taxonomy in all but name: prompt chaining, routing, parallelization-with-aggregation, orchestrator-with-workers, evaluator/judge, verifier.

Where the course was pointing (late 2025)#

Three claims are worth holding as timestamps rather than as current facts:

• Static graphs, not open loops. "In most scenarios, you're still having very static workflows… it's easier for open-ended problems to construct this graph by hand of how a human would do it." Open-ended agent loops were "signs of life" confined to coding and deep research. This is the before state that Agent Loop Pattern and Agentic Loops Overtake Bespoke Systems document the field leaving.
• Coding agents had just become reliable. The terminal-loop coding agent "was not quite reliable last year, and it's just starting to get reliable" — attributed to more capable models plus RL with verifiable rewards, not to a new architecture. "I think the paradigm is very much the same."
• What agents needed next: planning, multi-step reasoning, self-correction — which is also the course's syllabus.

The course's own bet on where value lands: repetitive, verifiable work — code migrations, version upgrades, restructuring, data-engineering and warehouse migrations, unit tests — plus customer support (transcription, knowledge assist, smart replies, call summaries) and long-form report generation, with AI-as-scientist (idea generation, experiment iteration, paper write-up) as the forward-looking case. On hallucination in the science case the instructors take an unusual line: idea generation is a task where a wide, partly-unreliable proposal distribution is an asset, "way outside the box" being the point. Compare Autonomous Scientific Discovery and Research Taste as the Human Bottleneck.

The lecture-2 arc: test-time compute scaling#

Lecture 2 (Azalia Mirhoseini solo, delivered 2025-09-26) is the technical expansion of move 5 above, and it runs in three acts — each a paper, each pushing on the same question.

1. Large Language Monkeys, formalized. Repeated sampling is not just an observation, it has a scaling law: coverage against sample count follows a power law across model families and four orders of magnitude of parameter count. The lecture then supplies the mechanism — the law holds if and only if the benchmark contains a long tail of hard problems — and the consequence that compute is migrating from pre-training into inference, where it can be spent offline and indefinitely. Carried on Latent Capability Overhang.
2. The generation–verification gap, quantified. Majority voting plateaus at 10–50 samples while coverage keeps climbing; reward-model rankers barely close it; the gap widens on harder benchmarks. The mechanism is that the hardest solved problems are solved 1–3 times in 10,000, so any frequency-based selector is structurally blind to exactly the answers worth finding. Carried on The Verifiability Thesis.
3. Constructive answers. Snell et al.'s parallel-vs-sequential-vs-PRM-guided-search comparison and its difficulty-bin finding (Large-Scale Test-Time Compute), then Archon's search over composed inference architectures — where fusion turns out to beat oracle selection outright (Inference-Time Architecture Search).

The lecture's own summary of what carries: repeated sampling works, and the quality of the verifier is the binding variable — a student states it, Mirhoseini confirms it, and she offers the released 10,000-samples-per-problem dataset as a course project on shrinking the gap.

Two of its dated positions are worth timestamping. Mirhoseini says the claim that for easy and medium problems extra test-time compute beats extra pre-training, but for the hardest problems larger models still win is "still work in progress and I believe still the true observation as of today" — a late-2025 verdict recorded on Large-Scale Test-Time Compute, where the 2026 sources have since measured the same shape without settling the tradeoff. And she treats weakly-supervised verifier ensembling — 10 or 20 verifiers, not thousands, "very costly from a compute perspective" — as her lab's live answer to the verification bottleneck, previewed for a later lecture in the series.

The lecture-3 arc: robust verification#

Lecture 3 (Azalia Mirhoseini solo, delivered 2025-09-29) is the course's answer to the bottleneck lecture 2 diagnosed, and it is organized as a four-year progression rather than a survey: four papers, each fixing the previous one's limitation, ending at her own lab's.

1. Score the answer — OpenAI's 2021 GSM8K verifier: sample 100 completions, label by final-answer match, train a language model with a per-token correctness head to predict the label. Beats supervised fine-tuning once the verifier has enough data.
2. Score the steps — Let's Verify Step by Step (2023) and PRM800K's 800K human step labels. The real prize is not credit assignment but false positives: an outcome-labelled verifier rewards a solution that hallucinates its way to a correct answer, and a process-labelled one does not.
3. Score the steps without humans — Math-Shepherd (2024) defines a step's label as the fraction (or existence) of rollouts from it that reach a correct answer, and uses the resulting PRM both as a test-time selector and as an RL reward.
4. Stop training verifiers — Weaver (Stanford, 2025): normalize a heterogeneous pool of ORMs, PRMs and LLM judges, drop the bad ones against ~1% of labels, learn per-verifier weights by Snorkel-style weak supervision, then distill the whole pool into a ~400M scorer.

Steps 1–3 live on Process vs Outcome Reward Models; step 4 on Weak-Verifier Ensembling. Three things the lecture supplies that the rest of the wiki did not have:

• A trained verifier's precision decays with candidate count. Accuracy rises to roughly 400 samples and falls by 800, because near-identical candidates get harder to separate — a second component of the generation–verification gap distinct from majority voting's consensus blindness, and the reason the 2021 system shipped at 100 samples.
• The arc contains its own refutation, unremarked. Process supervision exists because outcome labels reward hallucinated-but-correct chains; Math-Shepherd's automatic step label is defined by whether the step reaches a correct answer. Automating the annotation reintroduces the exact failure the annotation was for. Mirhoseini states both halves and never places them together.
• The generator-vs-verifier budget split is named as unsolved. Under fixed compute, sample more solutions or score each one harder? Offered twice as a course project, both times without an answer.

Her closing positions, held as dated practitioner-opinion: repeated sampling should migrate to training time so that pass@1 carries the load — "that's the direction we want to go" — with the caveat that sharpening a model onto one answer may cost the solution diversity and creativity that made sampling work in the first place. And on whether generator and verifier should share a model family, she has no study to cite, only the observation that models "like their own generations" (Same-Model Review Blindness) — an observation in tension with her own lab's cross-lab verifier pool.

The lecture-4 arc: where the feedback comes from#

Lecture 4 (Aakanksha Chowdhery solo, delivered 2025-10-03) is the first to leave verification behind and ask a different question. Lectures 2–3 asked how good is the signal; lecture 4 asks where the signal comes from, and organizes three papers by their answer:

Paper	Feedback source	What it improves
ReAct	the environment, at inference, no training	grounding — Reasoning–Acting Interleaving (ReAct)
RLEF	the interpreter, as an RL reward	code correctness — RL from Execution Feedback (RLEF)
Constitutional AI	the model itself, against human-written principles	harmlessness — Alignment Fine-Tuning (AFT)

Chowdhery's own framing: "all three of those techniques are ways for the model to improve itself. But what differs in each of these techniques is where is the feedback coming from?" Read against The Verifiability Thesis, the three are ordered by how much of a verifier they get for free — an environment that returns observations, a test suite that returns a bit, and a critic that is the model under training. The third is the course's only answer for a domain with no external check at all, and its price is visible in the results: harmlessness rises and helpfulness falls, and the paper's contribution is a Pareto frontier rather than a win.

Two things carry beyond their papers. The interleave got absorbed. Chowdhery says twice that today's thinking models do ReAct unprompted because they were distilled on these traces — Harness Shrinkage as Models Improve observed on a named primitive. And the repair skill, not the correctness skill, is what execution feedback installs: RLEF's error analysis shows later turns fixing the specific failure, with no pressure anywhere toward getting it right on turn 1.

Her standing caution runs through all three: the models are not well calibrated about what they know, so an application should not gate tool use on the model's own confidence — "getting the model to use the right set of tools so that you have grounded knowledge" is the substitute. And on self-critique specifically she volunteers what the Constitutional AI results do not show: "often times getting the model to critique itself can be harder. So having a consensus of other models to critique the models sometimes works better." See Same-Model Review Blindness.

COI, third instance in four lectures. Constitutional AI is Mirhoseini's paper (Bai et al. 2022), taught by her co-instructor without disclosure; the ReAct experiments run on PaLM, of which Chowdhery is lead author; and the enumerated-valid-action technique she recommends comes from a Google robotics collaboration she describes as her own. The course's pattern of teaching its instructors' work is by now structural rather than incidental.

The lecture-5 arc: three places to put the planning#

Lecture 5 (Azalia Mirhoseini solo, delivered 2025-10-06) is the syllabus item lecture 1 promised — what agents need next: planning, multi-step reasoning, self-correction — and its three papers turn out to be three different answers to where the planning lives, which the lecture never states as its axis:

Paper	Where the planning goes	Cost paid
LATS (ICML 2024)	in the harness, at inference: MCTS over trajectories — Tree Search over Agent Trajectories (LATS)	more inference, unmeasured; needs a reversible environment
SPRINT (2025)	in the weights, as trace structure: emit independent plans together — Intra-Trace Parallel Planning (SPRINT)	an SFT run; wall-clock gain still unproven
SWiRL (COLM 2025)	in the weights, as step quality: per-step judge reward over offline trajectories — Offline Multi-Step Tool-Use RL (SWiRL)	a judge that is the only signal at every step

The two axes the course has been running are both visible here. On the verification axis, LATS steers its search with an LLM judge summed with a per-node majority vote, and SWiRL's every reward is a prompted judge — so the lecture's answer to lecture 2's bottleneck is, in practice, "use a judge and don't measure it." On the self-improvement axis, SPRINT and SWiRL are both instances of the flywheel with an unusual payload: a second model annotates the first model's trajectories (GPT-4o segmenting DeepSeek-R1's reasoning into a plan/execution DAG; a judge scoring each proposed tool call), and the annotation becomes the training data. What gets improved is not the answer but the shape of the process.

Two findings the wiki did not have. SWiRL's process-filtered data beats outcome-filtered data for RL, and the ordering reverses for SFT — because outcome filtering keeps only problems the model already solves, while imitation learning cannot afford a trajectory that ends wrong. And cross-tool transfer: training on GSM8K with a calculator lifts HotpotQA with a search engine by roughly as much as training on HotpotQA does. SPRINT reports the same shape from math to countdown and GPQA-diamond. Both papers land on the same reading — what generalizes is a manner of reasoning, not a task or a tool.

COI, fourth and fifth instances. Two of the three papers are Mirhoseini's own lab's. She narrates both in the first person — "when we started the project", "we did not need to train an LLM as a judge for this" — which discloses the authorship by pronoun and never by name, the same pattern as lecture 2's Archon. LATS is the exception: not hers, and the only one she critiques structurally (no cost analysis, and the reversibility assumption).

One aside worth keeping as a late-2025 timestamp: she flags the Claude Sonnet 4.5 system card as notable for a prompt that "encourages the model to use tools as much as possible and at least 100 times," reading it as evidence the field had moved past the 8–10K-token problem into a regime where a single task means a hundred tool calls. See Large-Scale Test-Time Compute and Task Time-Horizon Scaling.

The lecture-6 arc: the loop closes, and what it does not buy#

Lecture 6 (Aakanksha Chowdhery solo, delivered 2025-10-10) is the one the course has been building toward since lecture 1 — train-time scaling, defined in a single sentence the lecturer says is the whole lecture: "if you take what the model output, filter after applying this test time scaling, and then use that to fine-tune further — that's roughly what train time scaling is." Everything before it was test-time; this is where the flywheel's second half gets a mechanism.

Its three papers are one ladder rather than three answers, ordered by how much of an RL loop you are willing to build:

Paper	The loop	Signal	Price of admission
STaR (2022)	offline: generate, filter, fine-tune, repeat — Rationale Bootstrapping (STaR)	1/0 on the final answer, plus a hinted rationale for the failures	~100 seed rationales, no RL infrastructure
DeepSeekMath (2024)	online, group-relative, critic-free — Group Relative Policy Optimization (GRPO)	group-normalized reward-model score	a primed base model and a curated corpus
DAPO (2025)	online, plus four fixes for long chains of thought — same page	same, with degenerate groups discarded	control of entropy, response length and truncation

The lecture's own selection rule, and it is the most portable thing in it: STaR when you have ~100 reasoning examples and no RL infrastructure; GRPO when you have a good enough base model and limited GPUs; DAPO when reasoning chains get long, which is what "harder problems" means operationally.

The headline result is a negative one, and it is the course's most quotable line. DeepSeekMath's RL improved majority@K and not pass@K — "the model actually became more consistent, not fundamentally smarter." Held against Latent Capability Overhang (the same lab's Large Language Monkeys, where coverage is the whole story) the two are complementary rather than opposed: repeated sampling reads capability out of the tail, and RL post-training moves probability mass onto answers the model could already reach. Neither adds a problem to the reachable set. Chowdhery says so herself when a student asks — the step change in fundamental capability "has typically been seen by either some sort of a breakthrough or by scaling." That is the course's own thesis about self-improvement, bounded by the course's own instructor, in the lecture where the loop finally closes. See Large-Scale Test-Time Compute.

Three smaller things the lecture supplies that the wiki did not have:

• RL's share of training compute, as of late 2025. Asked how much of a frontier model's training is now RL versus next-token prediction on scraped text, Chowdhery's estimate is roughly 1% a year earlier, perhaps ~5% now — with the caveat that she is not describing Anthropic's undisclosed split, and that Grok 4 claimed 50% RL and "did not quite improve" proportionally, because "you're bottlenecked by your rewards not being strong enough, or noise in the rewards." A rare public number for the axis, and a rare vendor claim graded in the same breath.
• RL versus SFT, plainly. RL hill-climbs with fewer examples wherever a strong reward signal exists, but takes real work to get right; SFT is faster when you already have high-quality data and "doesn't bring reasoning capabilities or boost them."
• The open problems she names, which double as the course's project list: why only majority@K rises; whether the backtracking and self-correction visible in reasoning traces are emerging behaviours or pre-existing ones becoming statistically more prevalent; and that learning from failures is unsolved — a few papers try, and the field's standing practice is still to filter failures out.

COI: none on the papers, for the first time in five lectures. STaR is Stanford but not the instructors' (Zelikman & Goodman's lab; the lecture says only "an author at Stanford"), and DeepSeekMath and DAPO are DeepSeek's and ByteDance-Seed's. The only self-reference is oblique and against interest: the Minerva-on-PaLM result is used as the baseline DeepSeek beat, and Chowdhery is PaLM's lead author. Worth recording precisely because it breaks the pattern — the disclosure gap in lectures 2–5 tracks whose paper is being taught, not the instructors' habits generally.

The lecture-7 arc: two kinds of search, and the curation problem underneath both#

Lecture 7 (Aakanksha Chowdhery solo, delivered 2025-10-17) is the course's homework lecture — its first half previews homework 2 (repeated sampling on HumanEval) and its second half previews homework 3 (a deep research agent) — and the two halves look unrelated until the opening sentence names the shared axis:

"We kind of know that the solutions lie in the search space of the models, but how do you curate the answer out of the search space of what the model outputs is roughly what we are covering."

Everything the course has taught about test-time compute produces candidates. This lecture is about what you keep, in two settings where the constraint is different:

Half	System	The scarce thing	Where it lands
Code	AlphaCode (2022) → AlphaCode 2 (2023)	submission slots — 1M samples, 10 attempts	Selection Under a Submission Budget
Retrieval	RAG → agentic RAG → Search-o1 (2025)	context the model reasons well over — 10–20 documents is already too many	Retrieval Inside the Reasoning Chain

The code half supplies the wiki's first direct price on the selection stage. AlphaCode's pipeline is mostly a selector — filter 1M samples against the example tests, cluster the survivors into semantically-equivalent groups using a separately trained test-input generator, submit one per cluster — and the lecture defines the metric that measures what that costs: 10@k against pass@k, generate k and submit ten versus generate k and submit all k. The gap is roughly 30% against above 40% solve rate. Two findings survive the ASR cleanly: the log-linear scaling of solve rate in sampling budget holds under the submission cap (selection lowers the curve, it does not flatten it), and clustering is worth a consistent margin at every budget because with ten shots the only thing worth optimizing is behavioural spread. AlphaCode 2 then swaps the generator for a fine-tuned Gemini Pro family plus a learned scoring model and reaches AlphaCode's solve rate at 100 samples instead of 1,000,000 — Chowdhery's rule being that "making the model better is a slightly easier axis than scaling the number of samples."

The retrieval half supplies the missing ancestor of Deep Research Agents. Three rungs: RAG retrieves once before thinking starts and "in multi-step reasoning it definitely suffers"; agentic RAG emits searches mid-chain between special tokens and splices whole documents back in; Search-o1 adds a reason-in-documents module that reads each document against the current query and appends only the extracted chunk. The dividing evidence is a document-count curve — direct reasoning and RAG go flat or down as documents are added, Search-o1 goes up — which locates the failure being fixed in long-context reasoning over retrieved noise, not in retrieval. And the search trigger is the sharpest observation in the lecture: a knowledge gap is visible in the trace as hedging vocabulary ("perhaps," "alternatively," "wait") before it is visible in the answer, and Search-o1 measures its own effect by counting those markers.

Two things this lecture does to the course's own positions.

• It votes against the course's lecture-2 tradeoff, in a regime lecture 2 excluded. Lecture 2 endorsed extra test-time compute over extra pre-training on easy and medium problems; here the same course prefers a better base model to a 10,000× sampling budget on competitive programming. The two are compatible — hard problems were always the exception — and the course never places them side by side.
• It bounds its own scaling law from the inside. Asked whether one could simply sample a trillion times, Chowdhery agrees the arithmetic works only "if the log-linear trend continues" and names the assumption: "you kind of assume that if we sample more the diversity continues to increase… if you sample 10× more but you don't end up with more diverse solutions, then you're actually not going to improve." Latent Capability Overhang's "diversity is the fuel" stated as a ceiling on the curve, with clustering as the instrument that detects it.

Also worth recording: the closing discussion restates the course's standing calibration position with a mechanism — aggregate the output log-probabilities and "the models tend to be overconfident," a model 50% correct sounding 80% sure (illustrative figures, not a measurement), showing up behaviourally as refusing to change its mind under correction (Confident But Unsure). Search-R1 is named as the RL version of Search-o1's prompted loop and explicitly not covered — the course ran out of time.

COI: clean on the papers, second time in seven lectures. AlphaCode and AlphaCode 2 are DeepMind's, Search-o1 is Renmin University's, Search-R1 is not hers. Two residuals, both small: AlphaCode 2 is narrated as "this work was at Google" by a former Google Brain researcher who does not say she was there, and Large Language Monkeys is credited to "Azalia covered this" — the co-instructor's lecture rather than her authorship. So the disclosure gap really does track whose paper is being taught: lectures 6 and 7, the two with no instructor-authored papers, are the two clean ones.

And one confirmation about the playlist. An aside — "that's AI scientist style of work that folks covered last lecture" — confirms the open-ended-evolution session (ADAS, The AI Scientist, AlphaEvolve) was taught on 2025-10-13 and simply is not in the published nine videos, which is the "curated subset" claim below getting first-party corroboration rather than inference from a syllabus.

The lecture-8 arc: three rulers, and the one that argues with the other two#

Lecture 8 (Aakanksha Chowdhery solo, delivered 2025-11-17) is the course's evaluation lecture, and it is the first one whose organizing question is how would you know. Its three benchmarks are three different answers to what an agentic evaluation should measure, and the middle one exists to contradict the first:

Benchmark	What it measures	Trend it reports
METR time horizons	task duration at fixed reliability — Task Time-Horizon Scaling	doubling every ~7 months (late-2025 figure)
GDPval (OpenAI)	win rate against a 10-year professional on real paid work — GDPval Benchmark	roughly linear, ~12% → ~48% over two years
DeepScholar-Bench (Stanford/Berkeley)	research-synthesis quality: retrieval, key facts, citation verifiability — Deep Research Agents	no system above ~19%

The lecture's own thesis is deflationary, and it comes from the course's own instructor. Chowdhery names the extrapolation the exponential invites — "okay so now AI can do one hour so next it will be able to do couple of hours" — and offers GDPval against it: on work that actually takes hours to weeks, the models are only so useful, and the usefulness is broken down by profession rather than aggregated into a horizon. The course whose thesis is a self-improvement flywheel spends its evaluation lecture installing a brake, which is the same move lecture 6 made with majority@K-not-pass@K.

Three things this lecture supplies that the wiki did not have.

• The construction of METR's number, which the wiki had only ever quoted: three suites (SWAA / HCAST / RE-Bench, ~170 tasks), human baseliners with ~5 years' experience timing successful attempts, geometric-mean difficulty, a fitted success-versus-time curve. Plus the 80% column — 59 minutes at 50% reliability collapses to tens of minutes at 80% — and METR's three self-declared limitations, of which the sharpest is that models track low-context contractor times (5–18× slower than maintainers) rather than the expert times they are graded against.
• GDPval itself, which this wiki had been citing for months only through its Artificial Analysis Elo derivative on half a dozen model pages. Design, per-occupation results, and the failure analysis — where the dominant error class is instruction following, and its signature form is a model that promises to consult the supplied reference files and does not.
• A third benchmark with real headroom. DeepScholar-Bench generates related-work sections from post-cutoff arXiv papers on a monthly refresh, and nothing clears ~19%. Its failure modes are the useful part: relevant papers retrieved but foundational ones missed, ~50% key-fact coverage even when handed the correct sources, and no system strong at both synthesis quality and citation verifiability.

The synthesis is the lecture's contribution rather than any one benchmark. All three failures rhyme: what the model is missing is the context an embedded expert has — the codebase, the tacit specification, the field's foundational literature — and all three benchmarks are, in different ways, instruments for handing that context over and seeing what remains. See Context Advantage, Not Taste. Her closing position is that reliability's long tail is the hard part, attributed to "a mix of both a data problem and a fundamental model capabilities" problem, and her AGI definition is the flywheel's terminal case: "when AI can build the next generation of models themselves then we don't have to even be in the room" — which she says is not where things are.

COI: clean on the papers, third time running. METR is an independent evaluator, GDPval is OpenAI's, DeepScholar-Bench is a Stanford/Berkeley group's — none instructor-authored. One residual, in the harmless direction: a Stanford adjunct calls the third paper "out of Stanford" without saying she is not an author. The standing finding holds — the disclosure gap tracks whose paper is being taught, and lectures 6, 7 and 8 (all Chowdhery-solo, none teaching instructor-authored work) are the three clean ones.

The lecture-9 arc: the loop's three unsolved inputs, and the bill for running it#

Lecture 9 (both instructors, delivered 2025-12-05) is the closing session, and it does two things that do not obviously belong together: Chowdhery surveys three 2025 papers on the self-improvement loop, then Mirhoseini presents an efficiency metric. The join is stated once and is the lecture's actual thesis — "we can do the self-improvement, but you're now doing a lot more inference and there's a cost to this intelligence." A flywheel is an inference-heavy object, so the course's last word is the electricity bill for its first eight.

The survey half is organized by what is still human-supplied or unreliable at the loop's inputs, one paper each, and Chowdhery names the three explicitly rather than leaving them to be inferred:

Bottleneck	Paper	The move	Where it lands
Reasoning chains stop being diverse, so the loop plateaus	Multiagent Finetuning (MIT/Google, ICLR 2025)	fine-tune one base model into generation and critic specialists; debate, summarize, majority-vote, retrain	Rationale Bootstrapping (STaR)
The verifier is unreliable and can invent its own errors	DeepSeek-Math V2 (late 2025)	a meta-verifier grading the verifier's analysis — do the issues it named exist, does the score follow	Process vs Outcome Reward Models
Training prompts are statically curated by human experts	Absolute Zero (2025)	the model proposes its own tasks under a 1 − success rate learnability reward, gated by execution	Rationale Bootstrapping (STaR)

The efficiency half is intelligence per watt — accuracy divided by power draw, from Mirhoseini's Stanford work with Christopher Ré and John Hennessy: local models (≤20B active) covering the great majority of single-turn chat and reasoning queries, an Apple M4 Max at ~1.5× lower efficiency than a B200, and a 5.3× two-year gain that decomposes into 3.1× model × 1.7× hardware. Her forward call is hybrid local/cloud routing and energy as the binding resource.

Four things this lecture supplies that the other eight did not.

• A mechanism for the plateau the course kept observing. Lecture 6 said STaR-style loops plateau and did not say why; lecture 7 said a sampling budget only pays if diversity keeps rising; lecture 3 said sharpening onto pass@1 may cost diversity. Lecture 9 names the same variable a fourth time and finally measures a proxy for it — a single model's generations converge even at high temperature, and embedding dissimilarity plotted beside accuracy is the readout. Diversity is the course's real axis, running under all nine lectures, and it is never given a lecture of its own.
• The verifier arc's next rung, from the course's own logic. Lecture 3 left an unremarked refutation: process supervision exists because outcome labels reward hallucinated chains, and Math-Shepherd's automatic step label is defined by outcome reachability. DeepSeek-Math V2 attacks the layer above — the verifier's reasoning, not its score — which is what the sting implied and lecture 3 did not propose.
• A second coordinate on "verifiable". Asked what falls outside verifiable problems, Mirhoseini's examples — chip-design simulation, wet-lab chemistry — are all domains with perfect verifiers that take days, against an RL loop needing thousands of steps. A verifier too slow to sit in the loop is not a verifier, which is a different failure from creative writing's subjectivity, and the wiki had been filing both under one heading. See The Verifiability Thesis.
• The scale term, stated twice and followed up by neither instructor. Absolute Zero reports larger models gaining more from self-proposed curricula; Mirhoseini corroborates from SWiRL that larger models are "better at absorbing this kind of data flywheel." Self-improvement is therefore complementary to scale, not a substitute for it — The Bitter Lesson arriving inside the method built to route around the data wall.

On what stays open, the instructors are unusually direct. Mirhoseini's own list of unsolved problems includes the foundational one: why test-time scaling works at all — "what is happening that these correct answers are coming out?" — plus how to distill successful trajectories back into weights, and continual learning, which she frames as a mismatch rather than a missing feature: humans get more skilful as they work, models get an offline batch and a fine-tuning run later. Her idealized solution prices the alternative usefully — infinite perfect context would be continual learning, and it is not available because reasoning over in-context data degrades well before the window does.

COI: instructor-authored work returns after three clean lectures, and this is the best-disclosed instance in the series. Chowdhery's three papers are other groups' (MIT/Google, DeepSeek, Tsinghua) — her fourth consecutive clean half. Mirhoseini presents her own work and names it: "a recent work that we did, in collaboration with Professor Ré and Professor John Hennessy", and Hydragen and Tokasaurus as "my lab did some of this work." Compare lectures 2 and 5, where her lab's papers were narrated in the first person with no named authorship. The refined standing finding: the disclosure gap tracks not only whose paper is being taught but how it is framed — current lab activity gets named, a canonical citation in a survey slot gets a pronoun. Two residuals, both small: SWiRL is discussed as course material without restating her authorship, and Chowdhery attributes KernelBench to her co-instructor in the second person ("in your [lab]"), which discloses to the room and not to a reader.

The course, closed out#

Nine lectures, four presenters' worth of material, one thesis stated in lecture 1 and never abandoned: test-time compute manufactures verified trajectories, those become training data, the better model scales further at test time. What the compiled series actually shows is a course that spent eight lectures qualifying its own thesis, always with a measurement rather than a hedge.

The qualifications compound in a specific order. Lecture 2 established that sampling produces coverage no selector can keep. Lecture 3 showed that trained verifiers degrade past a few hundred candidates. Lecture 6 measured the loop's payoff and found majority@K rising and pass@K flat — more consistency, not more capability. Lecture 7 bounded the sampling curve from inside: it only continues if diversity does. Lecture 8 put a benchmark against the field's favourite extrapolation and found economic win rate rising linearly where task duration rises exponentially. Lecture 9 supplies the mechanism the earlier lectures kept circling — diversity collapse — and then adds that the whole thing works better the larger the model already is.

Read together, that is a course whose own evidence says the flywheel is a compounding efficiency mechanism, not an ignition mechanism: it converts what a model can already reach into what it reliably produces, at increasing returns to base-model scale, gated everywhere by the cost and honesty of the verifier. Both instructors say the terminal version out loud — Chowdhery's AGI definition ("when AI can build the next generation of models themselves then we don't have to even be in the room") and her verdict that the current state is AI co-scientist — and neither claims the course's methods get there. Compare Recursive Self-Improvement and Intelligence Explosion Dynamics, where this wiki's 2026 sources argue the same shape with different instruments.

Three things make the series worth keeping in the wiki despite being a year old at publication. It is the only source here that teaches the underlying literature as a sequence — the 2021→2025 verifier arc, the STaR→GRPO→DAPO ladder, RAG→Search-o1 — rather than citing whichever paper a 2026 claim needs. It is repeatedly bounded by its own instructors in ways vendor material never is, which is why the dated practitioner-opinion tier still buys something. And its late-2025 timestamp makes it a usable before picture: static workflow graphs as the norm, coding agents "just starting to get reliable", RL at perhaps ~5% of training compute, open loops confined to coding and deep research. Every one of those is a claim the 2026 corpus can be checked against.

The gap that remains is the one the course kept deferring and the one this wiki cannot close from these sources: nothing in nine lectures runs the loop in a domain without a cheap verifier. Mirhoseini names the experiment — push self-improvement as far as it goes on verifiable synthetic data and measure what transfers to domains with no automated verification — and calls it "a very compute-heavy research experiment" that nobody has run.

Structure and logistics (Autumn 2025)#

Grading	3 homeworks = 50%; course project = 50%
Project teams	2–4 people (1 allowed), API credits provided
Milestones	proposal (early Oct) → midterm presentation (~2 weeks later, experiments expected to have run) → final report → poster session, Dec 12, 4–6pm, with industry attendees
Wanted projects	a new eval dataset or benchmark; an agentic-system reliability study; hill-climbing an existing benchmark; extending or questioning a decision in one of the assigned papers
Rejected projects	survey papers; "just an app you put together"; "something more than live coding"
Guest lectures	frontier-lab researchers, on post-training evolution and multimodal/robotics agents

Homework 3 is new to this offering; one homework covers LLM-as-a-judge (LLM-as-a-Judge) and one the long-form report generator. Prior-year projects produced publications.

Lecture ledger#

All nine published lectures, compiled 2026-08-17.

#	Lecture	Presenter	Raw	Compiled
1	Course Overview	both	CS329A Self-Improving AI Agents — Part 1: Course Overview	2026-08-17
2	Test-Time Compute Scaling	Mirhoseini	CS329A Self-Improving AI Agents — Part 2: Test-Time Compute Scaling	2026-08-17
3	Robust Verification	Mirhoseini	CS329A Self-Improving AI Agents — Part 3: Robust Verification	2026-08-17
4	Learning from Feedback with Tools and Code	Chowdhery	CS329A Self-Improving AI Agents — Part 4: Learning from Feedback with Tools and Code	2026-08-17
5	Planning and Multi-Step Reasoning	Mirhoseini	CS329A Self-Improving AI Agents — Part 5: Planning and Multi-Step Reasoning	2026-08-17
6	Train-Time Scaling and Scaling RL	Chowdhery	CS329A Self-Improving AI Agents — Part 6: Train-Time Scaling and Scaling RL	2026-08-17
7	Self-Improvement with Search & Deep Research Agents	Chowdhery	CS329A Self-Improving AI Agents — Part 7: Self-Improvement and Deep Research Agents	2026-08-17
8	Agentic Evaluations and Long-Horizon Tasks	Chowdhery	CS329A Self-Improving AI Agents — Part 8: Agentic Evaluations and Long-Horizon Tasks	2026-08-17
9	Future Research Areas	both	CS329A Self-Improving AI Agents — Part 9: Future Research Areas	2026-08-17

The published series is complete as of 2026-08-17 — all nine YouTube videos are compiled. Anything further from this course would have to come from the unpublished sessions listed below.

What the published playlist is not. The nine YouTube videos are a curated subset of the syllabus's 20 sessions (1–6, 8, 17, 20), so the course as taught is larger than the course as recorded. Missing and squarely in this wiki's territory: the open-ended-evolution session (ADAS, The AI Scientist, AlphaEvolve), Agentic Frameworks for Software Engineering, and Augmenting Agents with Memory — plus six guest lectures and three midterm presentation days, plausibly withheld for speaker release rights. Presenter attribution per lecture comes from Stanford's own video descriptions: Mirhoseini solo on 2, 3 and 5; Chowdhery solo on 4, 6, 7 and 8; both on 1 and 9.

Connections#

• Azalia Mirhoseini — co-instructor; her lab's Large Language Monkeys is the course's inference-scaling anchor
• Aakanksha Chowdhery — co-instructor; supplies the coverage→pass@1 framing and the agent-workflow half of lecture 1
• Large-Scale Test-Time Compute — the course's central axis, taught as the third scaling frontier after parameters and data
• Recursive Self-Improvement — what the course means by "self-improving": the test-time-compute → synthetic-data → fine-tuning flywheel
• The Verifiability Thesis — the course's stated bottleneck, named in lecture as the generator–verifier gap
• Latent Capability Overhang — Large Language Monkeys is this page's 2024 empirical ancestor
• Agent Loop Pattern — the goal/act/feedback/stop definition the course uses to separate agents from chatbots
• Inference-Time Architecture Search — lecture 2's constructive answer: Archon, and the fusion result that beats a perfect selector
• Process vs Outcome Reward Models — lecture 3's first three papers: the 2021→2024 arc from outcome labels to human step labels to automatically-generated ones, and the false positive that survives all three
• Weak-Verifier Ensembling — lecture 3's fourth paper and the course's own lab answer: combine imperfect verifiers instead of training a better one
• Reasoning–Acting Interleaving (ReAct) — lecture 4's first paper: ReAct, the thought/action/observation alternation the course treats as the origin of tool calling
• RL from Execution Feedback (RLEF) — lecture 4's second: the interpreter as reward function, with a two-tier public/private test split and one advantage per episode
• Alignment Fine-Tuning (AFT) — where lecture 4's third paper lands: Constitutional AI as the AI-feedback substitute for RLHF's human labellers, and the helpfulness/harmlessness frontier it buys
• Tree Search over Agent Trajectories (LATS) — lecture 5's first paper: LATS, MCTS over an agent's trajectories with a judge-plus-frequency value function, and the reversibility assumption that confines it to simulators
• Intra-Trace Parallel Planning (SPRINT) — lecture 5's second: SPRINT, recovering the DAG hidden inside a reasoning trace and training the model to emit it, with an unintended accuracy gain
• Offline Multi-Step Tool-Use RL (SWiRL) — lecture 5's third: SWiRL, multi-step tool-use RL with every tool call moved offline, and the process-versus-outcome filtering inversion between RL and SFT
• Rationale Bootstrapping (STaR) — lecture 6's first paper: STaR, the minimal version of the course's own flywheel, and the rationalization step that lets it train on problems the model cannot yet solve
• Group Relative Policy Optimization (GRPO) — lecture 6's second and third: where GRPO came from and what DeepSeekMath credits for its headline, plus DAPO's four fixes for long-chain-of-thought RL and the Qwen-32B ablation ladder
• Selection Under a Submission Budget — lecture 7's code half: AlphaCode and AlphaCode 2, the 10@k-versus-pass@k metric that prices the selection stage, clustering as a diversity selector, and the learned scoring model that reaches the same solve rate at 100 samples instead of a million
• GDPval Benchmark — lecture 8's middle third, and the wiki's anchor for a benchmark it had only been quoting through its Elo derivative: economically valuable work scored as a win rate against a 10-year professional, rising linearly where METR's horizon rises exponentially
• Task Time-Horizon Scaling — lecture 8's first third: the only description in the corpus of how METR's horizon is constructed, the 50%-versus-80% reliability gap, and the low-context-contractor reading of what the metric measures
• Deep Research Agents — lecture 8's last third: DeepScholar-Bench, the live related-work benchmark where no system clears ~19% and relevance keeps being mistaken for importance
• Inference Efficiency as Capability — lecture 9's second half and the course's only session on what the flywheel costs to run: intelligence per watt, the local-inference thesis, and the 3.1× model × 1.7× hardware decomposition of a 5.3× two-year efficiency gain
• Retrieval Inside the Reasoning Chain — lecture 7's retrieval half: the RAG → agentic RAG → Search-o1 ladder, hedging tokens as the knowledge-gap trigger, and the per-document compression that makes adding documents help instead of hurt

Open Questions#

• Does the course's stated flywheel (test-time compute → synthetic data → better model) hold past the domains with cheap verifiers, or does it stall exactly where the The Verifiability Thesis predicts? Partially answered by the completed series (lecture 9, delivered 2025-12-05) — and the answer is that the course never tests it, states why, and names the experiment. Three things it adds. (1) The instructors put the question in exactly these terms and leave it open: "how much we can push the frontier of self-improvement based only on the verifiable domains … and how much that generalizes to other domains where we don't have automated verification" — Mirhoseini's own framing, called "a very compute-heavy research experiment" that has not been run. (2) All the transfer evidence the nine lectures contain stays inside the verifiable region: code→maths (Absolute Zero), calculator→search engine (SWiRL), maths→countdown and GPQA (SPRINT), maths→GSM8K (Multiagent Finetuning). Four papers, one consistent finding — self-generated data transfers a manner of reasoning — and not one of them crosses into a domain without an automated check. (3) The obstacle is now decomposed into two unlike problems. Domains with a slow verifier (chip design, wet-lab chemistry) fail on latency against thousands of RL steps, and the proposed repair is a surrogate reward model trained offline to predict the simulator — buildable, and bounded by its data. Domains that are subjective (creative writing) have no ground truth to build a surrogate against, and modelling one invites reward hacking. The first is an engineering problem, the second is the thesis's actual boundary; what stays open is whether the surrogate route works, which no source here measures.

Resolved Questions#

• The instructors say the pretraining-vs-RL question — whether RL adds capability or only surfaces what pretraining already contained — has "no single point of consensus." Do the later lectures in this series resolve it, or does it stay open across all nine? Answered by the completed series (2026-08-17, all nine lectures compiled): it stays open across all nine, and the final lecture lists it as an open research direction rather than a settled one. Graded in three parts, since the question encoded lecture 1's implicit expectation that the course would converge on an answer:
• Right: the course does take a position on the methods it teaches, and backs it with a measurement rather than an opinion. Lecture 6's DeepSeekMath result — RL raised majority@K and not pass@K at 32 samples — with Chowdhery generalizing it across STaR, GRPO and DAPO: "none of these will yet improve the fundamental capability… or teach the model to solve new problems," step changes attributed instead to "a breakthrough or scaling." Lecture 7's diversity ceiling and lecture 3's ~400-sample verifier decay point the same way. The surfacing side wins on the evidence the course presents.
• Wrong: the expectation that the remaining lectures would settle the general question. They did not, and lecture 9 says so from the front — Mirhoseini's first-listed open direction is the foundational one, "why are we seeing this kind of property … what is happening that these correct answers are coming out?", alongside how to distill successful trajectories back into weights. A course whose thesis is the flywheel ends by asking why the flywheel works.
• Right for the wrong reason: the partial answer recorded after lecture 6 leaned on a single paper's ablation on maths, read off a slide. It has held up — but not because that ablation was decisive. It held because the course's other five measured results independently point the same way, and because lecture 9's own contribution is a third candidate for the binding variable (diversity collapse) that is neither pretraining nor RL. The honest form of the question turns out to be not "does RL add capability" but "what is the loop's binding input", and by the course's own final lecture the answer to that is chain diversity, verifier reliability, and task supply — none of which is the pretraining-versus-RL axis. Answered: see the lecture-6 and lecture-9 arcs above, and Large-Scale Test-Time Compute for the wiki's 2026 treatment.

Sources#

• CS329A Self-Improving AI Agents — Part 1: Course Overview — lecture 1, delivered 2025-09-22, published 2026-08-03 (practitioner-opinion, YouTube auto-caption transcript, ~11.7k words). Scaling-law and emergence recap, the ChatGPT post-training stack, Large Language Monkeys, reasoning models, the chatbot→agent transition, workflow-pattern taxonomy, application survey, and course logistics
• CS329A Self-Improving AI Agents — Part 2: Test-Time Compute Scaling — lecture 2, Azalia Mirhoseini solo, delivered 2025-09-26, published 2026-08-03 (practitioner-opinion, auto-caption transcript, ~9.7k words). The coverage power law and its long-tail condition, verification-method taxonomy, the generation–verification gap and why majority voting cannot close it, Snell et al. on parallel vs sequential vs PRM-guided search plus the difficulty bins and the pre-training tradeoff, and the Archon architecture-search system
• CS329A Self-Improving AI Agents — Part 3: Robust Verification — lecture 3, Azalia Mirhoseini solo, delivered 2025-09-29, published 2026-08-03 (practitioner-opinion, auto-caption transcript, ~10.7k words). Four papers on verification across four years: the 2021 GSM8K outcome verifier and its ~400-sample precision decay, Let's Verify Step by Step / PRM800K and the false-positive argument for process supervision, Math-Shepherd's rollout-based automatic step labels and their three confirmed drawbacks, and Weaver's weakly-supervised verifier ensemble with its ~400M distillation. Plus the closing discussion on CodeMonkeys, reasoning models, the pass@1 destination and its diversity cost
• CS329A Self-Improving AI Agents — Part 4: Learning from Feedback with Tools and Code — lecture 4, Aakanksha Chowdhery solo, delivered 2025-10-03, published 2026-08-03 (practitioner-opinion, auto-caption transcript, ~12.9k words). Three papers sorted by feedback source: ReAct's thought/action/observation interleave with its HotpotQA/FEVER/WebShop results and the hallucination-to-retrieval failure swap; RLEF's execution-feedback RL with the two-tier test split, turn-level value function and turn-by-turn repair analysis; and Constitutional AI's critique–revise SFT plus RLAIF preference model with the helpfulness/harmlessness Pareto frontier. Plus the discussions on model calibration, noisy environment feedback, scaling code agents past the context window, and constitution amendment as a continual-learning problem
• CS329A Self-Improving AI Agents — Part 5: Planning and Multi-Step Reasoning — lecture 5, Azalia Mirhoseini solo, delivered 2025-10-06, published 2026-08-03 (practitioner-opinion, auto-caption transcript, ~11.3k words). Three papers on planning: LATS's six-stage MCTS over agent trajectories with its judge-plus-self-consistency value function, UCT selection and reflection step, plus the conceded cost and reversibility limits; SPRINT's GPT-4o annotation pipeline turning DeepSeek-R1 traces into a plan/execution DAG, the 7B SFT, the ~3.5-point accuracy gain and ~40% sequential-token reduction, and the countdown/GPQA-diamond transfer; and SWiRL's offline synthetic trajectories with per-step LLM-judge rewards, the no-tools-during-RL objective, the process-versus-outcome filtering inversion between RL and SFT, and the cross-tool GSM8K↔HotpotQA generalization. Two of the three are her own lab's, narrated in the first person without a named disclosure
• CS329A Self-Improving AI Agents — Part 6: Train-Time Scaling and Scaling RL — lecture 6, Aakanksha Chowdhery solo, delivered 2025-10-10, published 2026-08-03 (practitioner-opinion, auto-caption transcript, ~13k words). Three papers as one ladder of train-time scaling: STaR's generate/filter/fine-tune loop and its rationalization step, with the GPT-J results, the three stated assumptions and the V-STaR / Quiet-STaR descendants; DeepSeekMath's Common-Crawl-over-arXiv data curation on a DeepSeek-Coder base, the four-model-copies memory argument for dropping PPO's critic, MATH 46.8 → 51.7, and the majority@K-not-pass@K finding; and DAPO's clip-higher / dynamic sampling / token-level loss / soft overlong punishment with the cumulative Qwen-32B AIME ladder from ~30 to ~50. Plus the SFT-versus-RL selection rule, the late-2025 RL-share-of-training-compute estimate with the Grok 4 claim graded against it, and the closing open-problems list. The first lecture with no instructor-authorship conflict on the papers taught
• CS329A Self-Improving AI Agents — Part 7: Self-Improvement and Deep Research Agents — lecture 7, Aakanksha Chowdhery solo, delivered 2025-10-17, published 2026-08-03 (practitioner-opinion, auto-caption transcript, ~12.1k words). Two halves under one axis (how do you curate the answer out of the model's search space): AlphaCode's 700GB-GitHub pre-train, GOLD-regularized CodeContests fine-tune, 1M samples per problem, example-test filtering and semantic-equivalence clustering via a learned test-input generator, the Codeforces top-54% result and its per-contest variance discussion, the 10@k-versus-pass@k definitions and the model-size × budget sweep with its ~30%-versus-above-40% selection gap; then AlphaCode 2's fine-tuned Gemini Pro family, CodeContests v2, learned scoring model, 95% filter rate, top-10-cluster rerank, the 100-samples-matches-1M and 43%-versus-25% results and the 85th percentile; then the RAG → agentic RAG → Search-o1 ladder with the reason-in-documents module, the hedging-token trigger, the chemistry worked example, the document-count curve, the GPQA diagonal comparison and the multi-hop QA claim; closing on log-probability calibration and overconfidence. Class discussions on adapting sample budget to difficulty, on hint-injection and STaR, and on scoring-model contamination. The second lecture with no instructor-authorship conflict, with two undisclosed residuals — AlphaCode 2 narrated as "this work was at Google" by a former Google Brain researcher, and Large Language Monkeys credited to the co-instructor's lecture rather than her authorship
• CS329A Self-Improving AI Agents — Part 8: Agentic Evaluations and Long-Horizon Tasks — lecture 8, Aakanksha Chowdhery solo, delivered 2025-11-17, published 2026-08-03 (practitioner-opinion, auto-caption transcript, ~12.9k words). Three benchmarks as three rulers for agentic evaluation: METR's time horizons — the SWAA / HCAST / RE-Bench suite split (~170 tasks), the ~5-years-experience human baseliners and geometric-mean difficulty rating, the GPT-2 → GPT-4 → Claude 3.7 Sonnet ladder at 50% reliability, the 80%-reliability gap, the GPT-4-versus-o1 failure taxonomy (planning, tool choice, arithmetic, premature abandonment, repetitive loops), and the three stated limitations including the 5–18× contractor/maintainer gap that model performance tracks; then GDPval — nine top-of-GDP sectors, 44 occupations, ~1,320 tasks with ~220 released, the O*NET digital-task filter, the task-characteristics list, the 12.4% → 47.6% win-rate trend and its explicit linear-versus-exponential contrast with METR, per-model strengths, the instruction-following failure analysis, the GPT-5 quality distribution, and the underspecification ablation; then DeepScholar-Bench — related-work generation over post-cutoff arXiv papers refreshed monthly across 22 domains, the three graded axes with ~70–80% human validation, the sub-19% ceiling, and the four failure modes. Closing synthesis on why no single metric suffices, plus Q&A on the reliability long tail, distributed systems as a hard domain, and her AI-co-scientist-not-AI-scientist verdict. All figures are slide readings through ASR and are hedged on the pages that carry them; three are flagged as damaged (the task count, the GPT-5 quality split, the cost/speed claim). The third consecutive lecture with no instructor-authorship conflict — METR, OpenAI and a Stanford/Berkeley group — with one harmless residual, a Stanford adjunct describing DeepScholar-Bench as "out of Stanford" without stating she is not an author
• CS329A Self-Improving AI Agents — Part 9: Future Research Areas — lecture 9, both instructors, delivered 2025-12-05, published 2026-08-03 (practitioner-opinion with its forward-looking directions at prediction grade — the raw's ingest tier of prediction was corrected on the full read, since three quarters of the session recounts published results; auto-caption transcript, ~10.5k words). The closing session in two halves. Chowdhery's: a course recap, then three papers framed as the loop's three unsolved inputs — Multiagent Finetuning (diversity collapse in single-model self-training, generator/critic specialists trained from one base, debate with summarization, the NLL-versus-embedding-dissimilarity slides and the GSM8K transfer check), DeepSeek-Math V2 (theorem proving as the domain where outcome matching certifies nothing, issue identification without reference solutions, the generator/verifier/meta-verifier architecture, the DeepSeek-V3 + GRPO substrate, eight iterations at pass@1 and ~42% best-of-32 on the IMO 2024 shortlist), and Absolute Zero (the expert-supply argument, deduction/abduction/induction task types, the 1 − average success rate learnability reward, the execution/safety/determinism validity gates, the task buffer and diversity conditioning, and the code→maths transfer). Mirhoseini's: the intelligence per watt metric and study with Ré and Hennessy, the demand and local-memory trends, the three findings and the 3.1 × 1.7 = 5.3× decomposition, and four forward directions (hybrid local–cloud routing, energy-efficient architectures and kernels, test-time-scaling serving infrastructure, energy as the scarce resource). Plus the closing Q&A: the taxonomy of non-verifiable domains and the surrogate-reward workaround, KernelBench's performance-profiling gradient, continual learning versus long-term memory, infinite context and Cartridges, weights-versus-memory-stores for skill transfer, and environments as proxies. None of the three papers is in raw/; every figure is slide-read through ASR, and the intelligence-per-watt headline coverage number is dropped mid-sentence by the transcript — the ~88.7% carried on Inference Efficiency as Capability comes from the raw's own description of the paper and is labelled as such. Other transcript defects flagged at point of use: the abduction task type is described identically to deduction, the verifier score range renders as "0.5 and 1", and the data-centre demand figure has garbled units. COI: instructor-authored work returns after three clean lectures, disclosed by name — Mirhoseini presents her own intelligence-per-watt work and names her collaborators, and names Hydragen and Tokasaurus as her lab's. The standing series finding sharpens rather than breaks: the disclosure gap tracks how the work is framed, not just whose it is — current lab activity gets named, a canonical citation in a survey slot gets a pronoun