DEV Community: Bruce He

CS146S Fall 2026: How to Watch and Follow Along Free

Bruce He — Fri, 11 Sep 2026 07:48:47 +0000

You can follow Stanford CS146S Fall 2026 for free starting Tuesday, September 22, but you can't watch it: as of September 11, 2026, there are no official lecture recordings, and the "CS146S video" playlist Google keeps surfacing is a third-party recap of last year's syllabus. That distinction matters more this year than last, because the Fall 2026 syllabus is a different course. Six of ten weeks are new topics, the grading now puts 30% on open-source contributions, and Tuesday/Thursday replaces Monday/Friday.

This page is the operational answer to the questions people keep landing here with: where the videos are (and aren't), the exact Fall 2026 calendar, what's free versus enrollment-only, what changed since Fall 2025, and a week-by-week plan that pairs each new theme with a tool you can run tonight. I'm deliberately not re-explaining the ten-week syllabus or the guest lineup here; that lives in my CS146S overview. And the lecture-by-lecture notes for the Fall 2025 material are in the CS146S study guide. This post is the layer on top for people who want to run the quarter in real time.

One receipt up front, because the calendar is the whole point. The official site's Calendar tab is client-rendered and currently links to #, so I pulled the Fall 2026 schedule straight out of the site's JavaScript bundle on September 11. Every date and speaker below comes from that data, not from a secondhand post.

What "CS146S Video" Actually Gets You

There is no official CS146S lecture video, and there never was. A student who worked through the Fall 2025 course wrote it plainly in his notes repo: "As of writing there are no video recordings of the lectures that are publicly available." Nothing on the Fall 2026 site changes that. Course materials and submissions go through Stanford Canvas; Ed Discussion links go "to enrolled students."

So what is the playlist that ranks for the query? It's CS146S The Modern Software Development on a channel called AI With Ryan: nine videos, 14 to 16 minutes each, 29,044 views as of this week, last updated February 16, 2026. They're AI-narrated summaries of the Fall 2025 slide decks. The Week 1 description even opens by calling CS146S a course on "scalable systems, real-world algorithms, and high-performance engineering," which it is not. They're fine as a commute-length preview of the 2025 topics. They are not lectures, and they cover a syllabus that Fall 2026 has largely replaced.

Here's the honest inventory of everything you can actually press play on:

Source	What it is	Term covered	Verdict
AI With Ryan playlist	9 AI-narrated recaps, 14-16 min each	Fall 2025	Preview only; not lectures
From Writing Code to Managing Agents (EO)	Interview with Mihail Eric	Course philosophy	Worth 30 minutes for the "agent manager" framing
The Modern Software Engineer (AAIF Live)	Conference talk by Eric	Course philosophy	Same thesis, different audience
Fall 2025 Google Slides	Linked per session on the /fall2025 syllabus tab	Fall 2025	The real primary source; 17 decks
Fall 2026 slides	Not posted as of Sep 11	Fall 2026	Check the syllabus tab each Tuesday

The practical consequence: "how can I watch it" has the same answer as "how can I follow along." You read the deck, do the reading, run the exercise, and you do it on the week the class does, so the guest-talk chatter on X and the speakers' own posts land while the topic is fresh. That's the plan in the second half of this post.

The CS146S Fall 2026 Calendar

Fall 2026 runs ten weeks, Tuesday and Thursday, from September 22 to December 3, in room 420-041. Tuesdays are Eric's lectures; Thursdays are mostly guests. Stanford's 2026-27 academic calendar puts instruction start on September 22, the study-list deadline on October 9, Thanksgiving recess November 23-27, last day of classes December 4, and exams December 7-11. The course skips the Thanksgiving week entirely, which is why Week 10 lands on December 1.

Wk	Tuesday lecture	Thursday session	Guest
1	Sep 22: Course intro + build Claude Code in 200 lines	Sep 24: How SOTA coding agents are designed (system prompts)	—
2	Sep 29: Advanced prompting + RePPIT, spec-driven development	Oct 1: Full introduction to MCP and tool calling	—
3	Oct 6: All about agent skills (incl. web skills)	Oct 8	Lee Robinson, VP DevRel @ Cursor
4	Oct 13: Customizing your setup (CLAUDE.md, AGENTS.md, hooks)	Oct 15	Boris Cherny, creator of Claude Code @ Anthropic
5	Oct 20: Agent readiness in your repos	Oct 22	Eno Reyes, CTO @ Factory
6	Oct 27: Agentic code review, best practices and architectures	Oct 29	Silas Alberti, SVP Research @ Cognition
7	Nov 3: Security in AI codebases	Nov 5	Isaac Evans, CEO @ Semgrep
8	Nov 10: Background agents, launching tasks asynchronously	Nov 12	Rajesh Bhatia, Senior Director @ Cloudflare
9	Nov 17: Guest, Elad Gil, investor @ Gil Capital	Nov 19	Amjad Masad, CEO @ Replit
—	Nov 23-27: Thanksgiving recess, no class
10	Dec 1: Coding agents in big teams (MCP portals, gateways, routing)	Dec 3: The Software Factory: self-running, self-improving systems	—

Two logistics notes for people outside California. Lecture times aren't published on the public site, only the days. And Pacific time flips from PDT (UTC-7) to PST (UTC-8) on November 1, 2026, so a Thursday afternoon guest talk is Friday early morning in Beijing, Singapore, or Tokyo either way, and one hour later after the switch. If you're following from Europe, Thursday afternoon Pacific is late Thursday evening for you. Since you can't attend anyway, what this actually affects is when the post-talk material shows up: speakers' slides and threads tend to land within 24 hours, so a Friday-morning check on the syllabus tab and on X is the habit that pays off.

(interactive diagram — view it on the original post)

What's New in Fall 2026 vs Fall 2025

Fall 2025 was a lifecycle tour; Fall 2026 is an operator's manual. The 2025 syllabus walked the SDLC (prompting, agents, IDE, terminal, testing, review, app building, ops, future). The 2026 syllabus assumes you already live inside a coding agent and asks how you configure, constrain, review, parallelize, and scale it. Here's the diff, item by item:

Dimension	Fall 2025	Fall 2026	My read
Days	Mon / Fri	Tue / Thu	Guest talks now mid-week; slides land before the weekend
Grading	Final project 80%, assignments 15%, participation 5%	Final project 50%, open source contributions 30%, assignments 15%, participation 5%	The biggest change on the page
Week 1	LLM basics, prompting	Build Claude Code in 200 lines, read production system prompts	Deep end, day one
Week 2	Agent anatomy, MCP	RePPIT + spec-driven dev, MCP	Specs promoted to a core method
Week 3	AI IDE, context	Agent skills + CLI	New
Week 4	Agent patterns	CLAUDE.md / AGENTS.md, hooks, subagents	New
Week 5	Warp terminal	Agent-ready codebases	Terminal week gone; readiness scoring in
Week 6	Testing + security	Agentic code review	Review gets its own week, earlier
Week 7	Code review	Security (SAST/SCA, prompt injection)	Swapped order with review
Week 8	One-prompt app building	Background agents, fleets, issue-to-PR	New
Week 9	Post-deployment ops	AI-native team: MCP portals, LLM gateways, cost routing	New
Week 10	Future of SWE	The Software Factory	New
Returning guests	—	Boris Cherny, Silas Alberti, Isaac Evans	Anthropic, Cognition, Semgrep again
New guests	—	Lee Robinson (Cursor), Eno Reyes (Factory), Rajesh Bhatia (Cloudflare), Elad Gil, Amjad Masad (Replit)	Two of the five run agent companies
Dropped	Zach Lloyd (Warp), Tomas Reimers (Graphite), Gaspar Garcia (Vercel), Resolve.ai, Martin Casado (a16z)	—	Terminal, UI-gen, and ops angles cut

The 30% for open-source contributions is the line to stare at. Fall 2025 was "build a thing"; Fall 2026 is "get a PR merged into a real project with an agent." The site lists fifteen open-source partners (OpenHands, marimo, CrewAI, Semgrep, Milvus, Unsloth, cmux, pi.dev, Arize Phoenix, Browserbase, CopilotKit, HeyGen, Vercel, Warp, Anyscale), and it's a safe bet that's the contribution pool. Read it as the instructor saying out loud that agent-built code that never leaves your laptop isn't the skill being taught anymore.

Two things haven't caught up yet, and you should know before you start. The assignments repo sits at 3,950 stars and 949 forks, but its last push was November 10, 2025; it still has week1 through week8 for the 2025 syllabus and nothing for 2026. And the Fall 2026 syllabus entries currently have topics and speakers but no readings, no slides, and no assignment links. I'd expect those to appear week by week, the way they did in 2025. Until then, the 2025 repo is the only runnable material, and about half of it maps cleanly onto the new weeks (the table further down says which half).

Free vs Enrollment-Only

"Is CS146S free?" has a two-part answer: the materials are, the course isn't. The Stanford bulletin lists it as 3-4 units, Letter or Credit/No Credit, with a September 27 application deadline for students who lack the formal prerequisites (CS111 and CS161 equivalents). The course FAQ says auditing is open "to Stanford students and staff." I searched for an SCPD or Stanford Online listing and found none, so as of today there's no route for a working engineer to enroll remotely.

You get	Free, public	Enrolled Stanford students only
Syllabus with topics, dates, speakers (both terms)	Yes
Fall 2025 slide decks, readings, 8 weeks of assignment code	Yes
Fall 2026 slides and readings	As they're posted (none yet)
Lectures in 420-041, Tue/Thu		Yes
Guest Q&A (Cherny, Robinson, Masad, and the rest)		Yes
Ed Discussion, Canvas, office hours (Fri 12:00-12:30)		Yes
Graded assignments and final project feedback		Yes
Open-source contribution as a graded, scaffolded deliverable	Self-imposed only	Yes
Units on a Stanford transcript		Yes
Tool subscriptions (Claude Code and similar)	Your own bill; the FAQ warns "some cloud-based services may require subscriptions"	Course "will provide access or alternatives where possible"

If you want live instruction from Eric without a Stanford ID, the only option is his paid Maven course, AI Software Development: From First Prompt to Production Code: four weeks, 3-4 hours a week, eight live sessions. Its module list mirrors the Fall 2026 themes almost line for line ("Build and Integrate an MCP Server or Agent Skill," "Implementing the RePPIT Dev Loop"), which tells you the new Stanford syllabus and the public course were designed together.

Two caveats I can't resolve from outside: the most recent cohort I can see in the page data ran June 22 to July 17, 2026, with no fall cohort listed yet, and the price isn't shown publicly without going through checkout. Treat it as the "I need feedback and a deadline" option, not the default.

The Follow-Along Plan: Each New Theme, Paired With a Tool

Every one of the five headline themes on the Fall 2026 site (MCP, agent skills, spec-driven development, loop engineering, the software factory) already has a runnable 2026 stack, and most of them have a deep-dive on this blog. That's the pairing that makes following along without a classroom actually work: the lecture gives you the why and the vocabulary; the tool gives you the reps.

(interactive diagram — view it on the original post)

The week-by-week version below is the thing to screenshot. "2025 material" is what's runnable today from the public repo and slides; "Do this" is the one exercise I'd spend the week's hours on; "Read" is the post on this blog that goes deeper than the deck will.

Wk	Dates	Theme	2025 material you can use now	Do this (4-6 hrs)	Read
1	Sep 22-24	Agent internals	2025 W2 Mon deck "Building a coding agent from scratch" + completed exercise	Write a 200-line agent loop with read/write/edit/bash tools; then diff it against a real CLI agent's system prompt	Study guide, Weeks 1-2
2	Sep 29-Oct 1	Specs, RePPIT, MCP	2025 W3 assignment "Build a Custom MCP Server"; W3 design-doc template	Ship one MCP server, then run the same feature spec-first with OpenSpec and compare token spend	OpenSpec + Superpowers workflow
3	Oct 6-8	Agent skills + CLI	None (new topic)	Convert one of your MCP tools into a SKILL.md + script; measure the context cost of each	MCP vs Skills: why CLI + Skill wins
4	Oct 13-15	CLAUDE.md, AGENTS.md, hooks, subagents	2025 W4 "Coding with Claude Code" assignment; Anthropic's Claude Code best practices	Add a lint/test hook that blocks bad commits; split one task into planner / implementer / reviewer subagents	Context engineering 2026
5	Oct 20-22	Agent-ready codebases	None (new topic)	Score one of your repos: docs, tests, checks, structure; fix the top two gaps an agent trips on	Triple stack: Claude Code + OpenSpec + Superpowers
6	Oct 27-29	Agentic code review	2025 W7 "Code Review Reps" assignment	Adversarially review an AI-written PR with a second agent as critic; count what it catches vs misses	Loop engineering: a critic that says no
7	Nov 3-5	Security	2025 W6 "Writing Secure AI Code" assignment; Semgrep blog on finding vulns with Claude Code	Run Semgrep on your agent-built repo; then try one prompt-injection attack on your own MCP server	Overview, Week 6 + guests
8	Nov 10-12	Background agents	None (new topic)	Wire one issue-to-PR trigger (GitHub issue label or Slack message) to a cloud-run agent; review the PR cold	Loop engineering: stop conditions
9	Nov 17-19	AI-native team	None (new topic)	Put an LLM gateway in front of your agents, route one cheap task to a cheaper model, look at the bill	Context engineering 2026
—	Nov 23-27	Recess		Catch-up week; this is when you land your open-source PR
10	Dec 1-3	Software factory	None (new topic)	Chain Weeks 4, 6, and 8 into one unattended pipeline: spec in, reviewed PR out; write down where it broke	MCP vs Skills

Notice where the 2025 material runs out: Weeks 3, 5, 8, 9, and 10 have no public assignment yet. That's not a reason to wait. Those are exactly the weeks where the 2026 tooling is furthest ahead of any syllabus, and the exercises above are what practitioners were already doing this summer. If the course posts an official assignment for one of those weeks, do that one instead and treat mine as the warm-up.

Two things not to do. Don't spend Week 1 re-reading the 2025 prompting deck; Fall 2026 skips prompting basics for a reason, and if you need them, the study guide's two-week core is faster. And don't stack the Maven cohort on top of this plan; the two overlap enough that you'd be paying for the same reps with a deadline attached.

One thing worth doing: pair CS146S with the agent courses running in parallel this fall, because they cover what CS146S deliberately skips (training and evaluating the agent itself). Stanford CS329Z: Engineering AI Agents (Diyi Yang, Sep 23 to Dec 2) has a public syllabus, though its recordings are Canvas-only. CMU's 11-768: AI Agents (Graham Neubig and Daniel Fried) is the one that actually posts lecture video: four Fall 2026 lectures were on YouTube as of September 11, with more landing as the term runs. And Stanford CS329A: Self-Improving AI Agents has all nine lectures from its last run on Stanford Online's YouTube channel. If you only have bandwidth for one companion, CMU's is the closest thing to the "watchable" course people keep searching for.

What You Lose by Not Enrolling

You lose the two things a syllabus can't ship: feedback on your final project, and being in the room for the guest Q&A. Everything else is recoverable with discipline. Here's the honest accounting:

Final project feedback (50% of the grade). A TA reading your project and telling you where the agent workflow was fake is the single most valuable thing enrolled students get. Substitute: post the project publicly and ask for review in the repo of the tool you used. It's worse, but it's not nothing.
Guest Q&A. Eight practitioners, including the people who run Cursor's developer relations, Anthropic's Claude Code, Factory, Cognition, Semgrep, Cloudflare's agent work, and Replit. You get their slides if they post them and whatever they tweet. You don't get to ask Boris Cherny why hooks are designed the way they are.
The 30% open-source scaffold. Enrolled students will have partner repos, presumably some mentoring, and a grade riding on a merged PR. You have the same fifteen partner repos on the public site. Pick one by Week 4, ship something by the Thanksgiving recess, and you've reproduced the deliverable, minus the grade.
Cohort pressure. The FAQ budgets 10-12 hours a week. Nobody following along on their own sustains that for ten weeks; 5-6 hours is what I've seen people actually keep up, which is why the table above scopes each week to one exercise.

What you don't lose is the content. Every deck the class sees will, based on the 2025 pattern, be a Google Slides link on the syllabus tab within days. The readings are public URLs. The tools are the same ones you'd install anyway. If you follow the calendar, do the exercises, and land one PR, you'll finish the quarter with more evidence of skill than most enrolled students had in December 2025, when the deliverable was still a solo project.

Where This Page Stops

This post is the calendar and the plan. It intentionally doesn't re-explain what each lecture teaches or grade the 2025 lectures; that's the job of the overview and the study guide. I'll update the calendar table if the course posts times, slides, or a Fall 2026 assignments branch, and I'll note it at the top when I do.

Three facts I couldn't verify and want on the record: the lecture time of day (not on the public site), the Maven course price and whether a fall cohort exists, and whether the 30% open-source contributions are restricted to the listed partner projects. If you're enrolled and know any of these, the comments are open.

ego lite Review: Handing Claude Code Your Logged-In Browser

Bruce He — Fri, 11 Sep 2026 07:48:11 +0000

The first real task I gave ego lite was the one its whole pitch rests on: open GitHub and tell me who's logged in. The agent came back in 65 seconds with "not logged in." I was logged in. So was the browser. The agent had simply been handed the wrong one of my two imported profiles, and nothing in the skill, the docs, or the UI had told it that a second profile existed.

That's the review in miniature. ego lite is the most ambitious answer yet to a problem this blog has been circling since January — how to give a coding agent a browser without paying for it in tokens, flakiness, or your own sanity. The series went from headless drivers (Vercel's agent-browser) to attaching to your real browser to cutting the token bill to zero to a 12-star repo with the right cost model and no maintainer. ego lite is the current end of that arc: one Chromium you use every day, in which your agents get their own Spaces, your logins, and a JavaScript API instead of a CLI. 15,666 GitHub stars as of September 10, 2026, up from about 7,900 when the Chinese tech press covered it on August 3.

I installed v0.5.0.28, drove it from Claude Code on three tasks of increasing difficulty, ran the same prompts through agent-browser and Chrome DevTools MCP, counted every token and every second, and then went looking for the seams. Cards on the table: at its best it was the cheapest agent browsing I have ever measured — one tool call, 16 seconds, twelve cents. At its worst it was the slowest — 30 turns and three minutes for a task agent-browser finished in 43 seconds. Both numbers are real, and the difference between them is a Claude Code setting, not the browser.

What ego lite actually is, from the binary up

ego lite is a closed-source Chromium 152 fork from Citro Labs, distributed as a free DMG; the MIT-licensed GitHub repo holds only the ego-browser skill and docs. The pitch has three parts: Spaces (isolated workspaces inside one window — you browse in yours, agents work in theirs), inherited state (it imports your Chrome or Edge profile, cookies and extensions included), and "code base, not CLI base" — the agent writes JavaScript that runs against the page in one pass instead of issuing one shell command per click.

None of the existing coverage — Hello.Reader's CSDN walkthrough is the clearest — explains what the CLI actually is, so I read the bundle. ego-browser is a 1.9 MB native arm64 Mach-O binary that lives inside the app (ego Framework.framework/Versions/0.5.0.28/Helpers/) and gets symlinked to ~/.local/bin at onboarding. It doesn't open a TCP port or a WebSocket; strings shows it talks to the running app over a Mojo named IPC channel (ego.mojom.EgoCliBootstrap and EgoCliBridge), the same transport Chromium uses between its own processes. Your script runs in an embedded Node 24.18 runtime (a separate ego Helper (Node) process), against a small, deliberately un-Playwright API: taskSpace(), page.goto(), page.snapshot(), page.click(), page.evaluate(), and page.cdp() as the escape hatch.

(interactive diagram — view it on the original post)

The install is genuinely two commands. npx skills add citrolabs/ego-lite dropped the skill into .agents/skills/ego-browser/ in 8.5 seconds (with a "High Risk" flag from the skills.sh scanner, which I'll come back to), and the app's own onboarding had already symlinked the same skill into ~/.agents/skills/ so every agent on the machine sees it. Typing /ego-browser in Claude Code loads a 19.5 KB SKILL.md — about 4,546 tokens by my count, versus 7,372 for agent-browser's core skill.

The app's own what's-new page for the September 10 v2.0.0 release claims the rewritten skill cuts memory 70%, cost 20%, and adds 10% to speed and success rate. No methodology is published for any of the four; keep that in mind when you read mine, which is.

Then it refused to run. Every ego-browser nodejs call answered "Please complete the onboarding process first. A setup window has opened" — with no setup window anywhere on screen, even though the app had imported my Chrome data two hours earlier. The missing step turned out to be an ego://onboarding page whose only content was "No importable browser data right now" and a Done button; pressing Done unlocked the CLI. Budget ten confused minutes for this.

The receipts: three tasks, three tools, one model

Method, so you can reproduce it. Claude Code 2.1.268, claude -p with --output-format json, model pinned to Sonnet for every run, on an M5 MacBook Pro running macOS 26.5. Wall time is measured around the process; turns, cost, and tokens come from the JSON result. The same prompt went to each tool; only the sentence naming the tool changed. Baselines: Vercel agent-browser 0.37.1 with its bundled skill, and Chrome DevTools MCP 1.9.0 headless. The three tasks: (a) list Hacker News' top five titles with points; (b) open github.com and report the logged-in user; (c) search docs.python.org for asyncio.gather, open the result, and return the first code block verbatim.

The first table is what you get if you run Claude Code the way most people do — permission prompts on, with an allow-list for the browser command.

Task	Tool	Wall	Turns	Cost	Calls blocked by Claude Code	Outcome
(a) HN top 5	ego lite	76.0s	12	$0.312	5 of 11	✅ correct
(a) HN top 5	agent-browser	39.9s	11	$0.298	4 of 10	✅ correct
(a) HN top 5	Chrome DevTools MCP	26.4s	6	$0.230	0	✅ correct (one 13,418-token snapshot)
(b) GitHub login	ego lite, default profile	64.7s	9	$0.242	5 of 8	⚠️ "not logged in" — wrong profile
(b) GitHub login	ego lite, profile named	35.6s	6	$0.178	2 of 5	✅ "logged in as heyuan110"
(c) Docs search	ego lite	194.8s	30	$0.751	11 of 29	✅ correct, painfully
(c) Docs search	agent-browser	42.6s	13	$0.305	1 of 11	✅ correct
(c) Docs search	Chrome DevTools MCP	51.3s	14	$0.325	0	✅ correct

Read the "blocked" column before anything else. ego lite's whole interaction model is a shell heredoc containing JavaScript, and Claude Code's Bash guard rejects any command where a brace sits next to a quote — which is to say any object literal: { keep: [] }, { scope: "full_page" }, { profileId: "Profile 1" }. The error is Contains brace with quote character (expansion obfuscation), and in -p mode it's a hard refusal, not a prompt. On task (c) the agent burned 11 of 29 calls on this, tried to write a script file instead (also refused — Write wasn't allow-listed), tried printf, tried JSON.parse('{"scope":"full_page"}') as a workaround, and eventually got there. agent-browser hit the same wall on its eval --stdin path, just less often, because most of its commands are flag-shaped.

ego's docs say to run Claude Code with "Full access." So I did — --dangerously-skip-permissions — and re-ran (a) and (c) for the two CLI tools. Chrome DevTools MCP wasn't blocked in the first round, so its numbers stand.

Task	Tool	Wall	Turns	Browser calls	Cost	Tool-result tokens	Outcome
(a) HN top 5	ego lite	16.4s	2	1	$0.123	151	✅
(a) HN top 5	agent-browser	19.0s	6	4	$0.176	177	✅
(c) Docs search	ego lite	40.5s	7	6	$0.219	3,805	✅
(c) Docs search	agent-browser	40.8s	12	10	$0.290	4,253	✅

That's the number the marketing is about, and it holds. On Hacker News, one ego-browser nodejs call — taskSpace, goto, waitForSelector, one page.evaluate that maps the rows to {title, points} — and done: 2 turns, 151 tokens of tool output, 16.4 seconds of which most is Sonnet thinking. agent-browser needed open, snapshot, eval, close. On the docs task, the two tie on wall time and ego wins on turns and cost by about 25%. ego's own homepage claims "up to 3.45× faster than agent-browser" on complex tasks (the README says 2.5×; the numbers aren't published); my complex task came out even on time and cheaper by a quarter. Not 3.45×, but a real win — with the setting that its docs recommend and that most security-minded readers of this blog won't use.

Where the token win actually comes from (not the snapshot)

Here is the misconception I most want to kill, because ego's own comparison matrix encourages it: the "compressed semantic input" checkbox. I loaded the exact same Hacker News front page in every tool and counted the snapshot each one hands the model, with the same o200k_base tokenizer I've used across this series.

Tool	Snapshot	Chars	Tokens
ego lite	`page.snapshot()` (viewport)	30,469	7,823
ego lite	`page.snapshot({scope:"full_page"})`	45,970	11,867
agent-browser	`snapshot` (full a11y tree)	27,845	7,368
agent-browser	`snapshot -i` (interactive only)	13,734	4,742
Chrome DevTools MCP	`take_snapshot`	39,123	13,418
Playwright MCP	`browser_snapshot` (my July article-page measurement)	28,874	~7,400
ubrowser	compact format (100-element HN page, July)	—	~1,720

ego's snapshot is not compact. It's a faithful accessibility tree with every table > table_row > table_cell level spelled out — Hacker News is nested tables all the way down, and the ego dump of the viewport alone costs more than agent-browser's interactive-only view of the whole page, and only 40% less than Chrome DevTools MCP's, which I called the most expensive in the business back in July. What it does have is refs ([ref=7, loc=href:/newest]) with stable-locator hints, iframe contents inline, and — per the v2.0.0 changelog — refs that survive page.evaluate calls, which was a real bug before September 9.

So why did the full-access run cost 151 tokens instead of 7,823? Because the agent never asked for a snapshot. It wrote page.evaluate(() => [...document.querySelectorAll(".athing")].slice(0,5).map(...)) and got back a five-line JSON array. That is the 65-token evaluate_script pattern I've been preaching since July, and ego's contribution is to make it the default path rather than the expert path: the skill tells the model to write code, the runtime lets a whole navigate-wait-extract sequence ship in one process, and the snapshot is what you fall back to when you don't know the page. That's the correct design. It's the same insight ubrowser had — batch the steps, ship only the answer — with an actual company behind it and a screenshot tool.

The flip side showed up on docs.python.org. When the page is unfamiliar, the agent has to snapshot, and ego's snapshot of that page cost 8,300 chars per look; the docs site has three input[name=q] search boxes (one hidden), so fill("css=input[name=q]") threw matched 3 elements, the @8 ref went stale after a re-snapshot, and the default-mode run spiraled to 30 turns. To be fair to ego, its error messages were the best of the three tools — "matched 3 elements (2 visible, 1 hidden). Candidates: 1. input 'Quick search' (hidden)…" tells the model exactly what to do next, which is what I dinged ubrowser for lacking. But the general rule from this series stands: the browser tool doesn't decide your token bill; the agent's habit of asking for facts instead of trees does. ego nudges the habit in the right direction and then hands you a tree as fat as anyone's when you ask for one.

"Your logged-in browser" — half true, and the half that's false matters

The headline feature is the one the first paragraph tripped over, so let me lay out exactly what happened. ego lite's onboarding found two browsers on my Mac and imported both: Chrome's profile became ego's Default (Bruce), Edge's became Profile 1 (he bruce). I live in Edge; that's where GitHub is signed in. taskSpace() with no arguments creates the space on the default profile, and the skill explicitly tells the agent not to "inspect or select profiles unless the user explicitly requests a particular profile." So the agent did the right thing by its instructions and got the wrong answer. Naming the profile — taskSpace("…", { profileId: "Profile 1" }) — produced logged in as heyuan110 in 36 seconds with 4 browser calls. If you have exactly one browser and one profile, you'll never see this. If you have two, or a work and a personal profile, you will, and the fix is one line the docs don't mention.

The bigger question is what "own Space" means for the data. The docs say each task space gets "its own native BrowserContext for cookies and storage," which any Playwright user reads as isolation. So I tested it: in task space A, on example.com, set document.cookie = "isotest=fromA" and a localStorage key; create task space B on the same profile, load example.com, read them back.

{"spaceA":2,"spaceB":3,
 "seenInA":{"cookie":"isotest=fromA","ls":"fromA"},
 "seenInB":{"cookie":"isotest=fromA","ls":"fromA"}}

Space B saw everything. Spaces isolate tabs, focus, and the window — the thing you see in the overview screenshot, the thing that keeps an agent from hijacking your mouse — but on one profile they are one cookie jar. That's exactly why the agent lands on GitHub already logged in, and exactly why you should think of a Space as a private tab group over shared state, not a sandbox. Two open issues sharpen the point: #303 reports cdp("Network.clearBrowserCookies") from an agent task space logging the user out of every site in the main Space, and #319 shows Storage.getCookies from a task space on a secondary profile returning the default profile's full jar — 1,105 cookies, other profiles' auth included. #315 puts the whole thing in one sentence: model-generated JavaScript runs in a privileged Node process with unrestricted raw CDP and unrestricted outbound HTTP, so a prompt injection on any page the agent visits is a prompt injection with your session cookies in scope. To their credit, the ego team answered all three within a week or two, and the reply on #319 is the most honest line in the whole project: "A space is not the same as a profile, and spaces do not isolate cookies," with per-profile space creation promised for 0.5.0.x — which is the profileId option I used above, so that part shipped. The raw-CDP exposure in #315 is acknowledged and not yet fixed, and the repo's private vulnerability reporting was returning 403 when the reporter tried it.

Isolation between users and agents, though, held up under everything I threw at it. Six task spaces opened and loaded six real pages in 8.2 seconds without touching my tabs; the app cold-started from fully quit to first snapshot in 2.1 seconds without stealing focus from my terminal (the focus-stealing bug filed against August builds didn't reproduce on 0.5.0.28); and the Spaces overview shows each agent's space labeled "running" with a live thumbnail, with a click to take it over. The CSDN piece quotes ego's own numbers for six concurrent tasks — "0.9 GB, 6 processes" for Space mode versus "15 GB, 84 processes" for six separate browsers — and for once a vendor number survived contact: my six spaces added exactly 6 processes and 0.91 GB of RSS (17 → 23 processes, 0.61 → 1.52 GB), and the browser reclaimed most of it within a minute of idling (back to 0.68 GB). I didn't measure the 84-process alternative; I believe it, and it's the least interesting comparison here, because nobody runs six full browsers for six tasks anyway.

Rough edges, in the order they cost me time

The -e flag blocks on stdin. ego-browser nodejs -e '…' never returns if its stdin is an open pipe — which it is inside most agent harnesses and CI runners. Three of my direct invocations hung until killed before I isolated it; < /dev/null fixes it. Heredocs are fine because the heredoc closes stdin.
The onboarding gate with no window. Covered above; ten minutes, ego://onboarding, press Done.
Extensions import disabled. Every Chrome extension arrived with "has been disabled — accept new permissions," and the app's first launch popped a permission bubble per extension in the toolbar. Fine for you; irrelevant to the agent, which doesn't get extension UI anyway.
Ownership flips silently. After my cleanup script called finish({ keep: [] }) on eight agent spaces, one survived as ownership: "user" — the GitHub tab had flipped it, per #314. It's harmless but it's a leaked renderer, and #270 says idle task spaces pile up across sessions.
Quitting loses your tabs. When I quit ego lite to test cold start, it came back to a fresh New Tab; the three tabs I'd had open were gone. Chromium's "continue where you left off" is off by default here, and I'd turn it on before making this a daily driver.
macOS only, and the roadmap says "Planned" with no date for Windows and Linux. #203, #345, and a WSL2 request are the most-upvoted feature issues. If you're on Windows, this article is a preview, not a recommendation.
The skills.sh scanner flagged the skill "High Risk" at install. Having read the skill, the flag is about capability, not malice: it teaches the model to run arbitrary JavaScript against a browser holding your cookies. That is the product. Decide accordingly.

Two things I expected to be rough and weren't: the skill's writing is excellent (the "use exactly one TaskSpace, print its id, resume it later" discipline saved the agent from tab sprawl in every run), and the v2 API's action receipts — popups, dialogs, downloads returned as data instead of surprises — are more thoughtful than agent-browser's.

Verdict: use it, on a dedicated profile, with full access, on a Mac

My one-line judgment: ego lite is the first agent browser where "your logged-in browser" is a two-command install and the token win is measurable rather than projected — but the win only appears when you run Claude Code in full-access mode, and the isolation it implies does not exist at the cookie layer, so it belongs on a dedicated profile with only the logins you'd hand an intern.

The comparison table I'd actually use, across everything measured in this series:

	ego lite	agent-browser	Chrome DevTools MCP	Playwright MCP	ubrowser
Interface	JS via `ego-browser nodejs`	CLI, one command per action	MCP tools	MCP tools	MCP tools (batch)
Your logins	✅ imported profile, shared jar	❌ (unless you `connect` to your Chrome)	✅ attach to real Chrome	❌	❌
Best measured run (HN)	16.4s / 2 turns / $0.12	19.0s / 6 turns / $0.18	26.4s / 6 turns / $0.23	—	1 call / 641 tokens (July)
Snapshot cost, HN front page	7,823 tokens	4,742 (`-i`)	13,418	~7,400 (July, article page)	~1,720 (July)
Default-mode Claude Code	❌ heredoc JS blocked	⚠️ `eval` blocked	✅	✅	✅
Screenshot / evaluate	✅ / ✅	✅ / ✅	✅ / ✅	✅ / ✅	❌ / ❌
Platforms	macOS	macOS / Linux / Windows	all	all	all
Maintained	v2.0.0 on 2026-09-10	active	active	active	abandoned Dec 2025

And the decision rule, since that's what you'll screenshot:

If you…	Use
Are on a Mac, run Claude Code with bypass permissions, and your tasks need your logins (dashboards, admin panels, your own SaaS)	ego lite, on a dedicated profile that's logged into only those sites
Run agents in default permission mode and want the cheapest clean-room browsing	agent-browser (`snapshot -i` + `eval`), or Playwright CLI in a skill
Are debugging your own frontend	Chrome DevTools MCP with targeted `evaluate_script`, as before
Need real isolation between the agent and your session	Not ego lite. Separate browser, separate profile, or a cloud browser
Are on Windows or Linux, or running in CI	Not ego lite, until the roadmap moves

Three concrete setup rules, earned the hard way. One: create a fresh ego lite profile for agents and sign it into only what the agent needs — the shared cookie jar means "inherits your logins" also means "inherits your bank." Two: if you keep two browsers, check profiles() once and put the right profileId in your CLAUDE.md, or your agent will confidently report "not logged in." Three: never -e without < /dev/null, and never cdp("Network.clear…") from a task space unless you enjoy re-authenticating everything.

The bigger picture, for anyone following the series: the field has now split cleanly into two philosophies. Drivers (agent-browser, Playwright, the MCPs) give you a browser the agent owns and you don't; ego lite gives you a browser you own and the agent borrows. The second is more useful and more dangerous in exactly equal measure, and the token economics — the thing I started measuring in January — turned out to be the easy part. Both camps have converged on "write code, ship the answer, don't ship the DOM." What separates them now is whose cookies are in the jar.

FAQ

What is ego lite and how does it work with Claude Code?

A free, closed-source Chromium 152 fork for macOS with agent-owned Spaces inside your daily browser. Claude Code uses the ego-browser skill: the agent writes JavaScript, the bundled native CLI sends it over Mojo IPC to an embedded Node runtime, and page.evaluate() runs inside the page. My best run was one tool call, 16.4 seconds, $0.12.

Is ego lite faster and cheaper than Vercel agent-browser?

In full-access mode, yes — 16.4s/$0.12 vs 19.0s/$0.18 on Hacker News; even on time and 25% cheaper on a multi-page docs search. In Claude Code's default permission mode it was slower, because heredoc JavaScript trips the shell sanitizer.

Do ego lite Spaces isolate the agent from my logged-in session?

No. A cookie set in one task space was readable in another on the same profile, and issue #303 shows a task-space cookie clear logging out the main Space. Spaces isolate tabs and focus; give agents a dedicated profile.

Does ego lite work on Windows or Linux?

Not as of September 2026. Both are "Planned" on the roadmap with no date.

Why does the skill fail with "expansion obfuscation" in Claude Code?

Because any JavaScript object literal in a heredoc puts a brace next to a quote, which Claude Code's Bash guard rejects in default permission mode. ego's docs say to use full access; the same docs task went from 30 turns to 7 when I did.

Series Navigation

This is Part 7 of the Browser Automation for AI Agents series — the arc from headless drivers, to attaching to your real browser, to cutting the token bill, to sharing your logged-in session:

Vercel Agent Browser — a snapshot-driven CLI built for agents, not test suites
Browser Automation in Claude Code: 5 Tools Compared — the field map — token cost, speed, stability
Chrome DevTools MCP Setup 2026 — attaching to your real browser, and the port 9222 traps
Playwright CLI + Skills: 0-Token Automation — the pattern that removes the MCP token tax
Claude Code Screenshot MCP Setup — the frontend debugging loop, 10,220 vs 65 tokens
ubrowser Review — the right design trapped in an abandoned repo
This article: ego lite Review — handing agents your logged-in session through Spaces

Originally published at heyuan110.com

Free AI Agent Courses Fall 2026: Stanford, CMU, MIT Compared

Bruce He — Fri, 11 Sep 2026 07:47:34 +0000

Five universities are running or have just published free AI agent courses for Fall 2026, and three of them you cannot watch. That's the fact to start from, because the search results won't tell you. Stanford CS146S, Stanford CS329Z, Stanford CS329A, CMU 11-768, and MIT's multimodal course all have public websites, syllabi, and reading lists; only two of them have lecture recordings you can play today, and only one is recording this term as it happens.

I've been covering Stanford CS146S since February, and its overview, study guide, and Fall 2026 follow-along are the most-read pages on this blog. That's why this hub exists: readers keep asking "which of these should I follow," and the answer isn't "all five" or "the Stanford one." As of September 9, 2026, I pulled every schedule from the official sites (for CMU, from the site's JavaScript bundle, because the page is client-rendered), counted the videos on every playlist, and read every grading table. What follows is the comparison, the honest inventory of what's actually free, and the stack I'd run.

The Five Courses at a Glance

The five aren't peers; they're three different kinds of course wearing the same "AI agents" label. CS146S is a practitioner course about working inside coding agents. CMU 11-768 and CS329Z are graduate courses about building and training agents. CS329A is a research seminar on agents that improve themselves. MIT's course is a multimodal ML course that happens to have an agents week. Here's the whole picture in one table:

Course	Term and dates	Instructors	Live video?	Slides / materials	Assignments public?	Prereqs	Best for
Stanford CS146S The Modern Software Developer	Fall 2026, Sep 22 to Dec 3, Tue/Thu	Mihail Eric	No (none, ever)	Syllabus public; Fall 2025 decks public; 2026 decks TBD	Fall 2025 assignments on GitHub; 2026 TBD	Programming	Engineers who use Claude Code / Codex daily and want the practice canon
CMU 11-768 AI Agents	Fall 2026, Aug 25 to Dec 3, Tue/Thu 3:30 to 4:50 PM ET	Graham Neubig, Daniel Fried	Yes, YouTube, updating (4 of 28 as of Sep 9)	Slides PDF per lecture (6 so far), readings	Assignment 1 starter repo public	Trained an LM before (11-667/11-711 level)	Builders who want the whole loop: harness, eval, RL training
Stanford CS329Z Engineering AI Agents	Fall 2026, Sep 23 to Dec 2, Mon/Wed 1:30 to 2:50 PM PT	Diyi Yang, Michael Ryan, John Yang	No (Canvas-only)	Syllabus and schedule public; slides TBD	Descriptions public; starter code not	CS224N-level NLP	Framework-literate builders who want a from-scratch harness plus eval discipline
Stanford CS329A Self-Improving AI Agents	Autumn 2025, Sep 22 to Dec 5, 2025 (replay)	Azalia Mirhoseini, Aakanksha Chowdhery	Yes, 9 lectures on Stanford Online (posted Aug 2026)	Schedule public; slides not linked	No	ML basics; RL helps	Anyone who wants the test-time compute / verifier / RL frontier explained by people who shipped PaLM and Gemini
MIT MAS.S60 / 6.S985 Modeling: Multimodal AI	Spring 2026, Feb 3 to May 12, 2026 (replay)	Paul Liang and three co-instructors	Yes, 13 of 28 sessions on YouTube	Slides for every lecture; application guest lectures slides-only	No	Deep learning basics	People building multimodal or GUI agents; not a general agents course

Two rows deserve a second look. CS146S and CMU 11-768 are both live this fall, both Tuesday/Thursday, and both run through December 3. If you follow both, you'll be doing four lecture-topics a week from September 22 on. And the two Stanford courses that are actually running this fall, CS146S and CS329Z, are the two with no public video. The "Stanford AI agents course" people search for is, this term, a reading assignment.

Which You Can Watch vs Which You Can Only Read

"Free" here means three different things, and the difference decides whether you can follow along. I sort the five into three tiers by what you can press play on as of September 9, 2026:

Tier 1, watchable live: CMU 11-768. The Fall 2026 playlist on Graham Neubig's channel had four lectures (57 to 76 minutes each) when I checked, covering the "What is an agent," tool use, long-context, and skills-and-memory sessions from August 25 to September 3. Slides are linked as PDFs for six sessions. The playlist had 1,413 views. That number matters: this is the least-discovered of the five, and the only one recording as it goes.

Tier 2, watchable as a replay: CS329A and MIT. Stanford Online put all nine CS329A lectures on YouTube in August 2026, ten months after the course ran; the playlist had 68,302 views when I counted, and the lectures run 63 to 75 minutes. Nine is not the whole course, though. The official schedule lists 18 sessions including guest lectures from Denny Zhou and Thang Luong (Google DeepMind), Misha Laskin (Reflection AI), and Danny Driess (Physical Intelligence); none of those guest sessions are in the published set. MIT's course has 13 videos out of 28 sessions; the application lectures (manufacturing, design, cities, transportation) and the tutorials are slides-only.

Tier 3, materials only: CS146S and CS329Z. CS146S has never released video, a point I documented in the follow-along post; what you get is the syllabus and, based on the 2025 pattern, Google Slides decks within days of each lecture. CS329Z's course page is explicit: cameras in the back of the room record instructor presentations, and recordings "can be accessed by logging into the course Canvas site." Everything else about CS329Z is public, including a week-by-week schedule and the two homework descriptions, which are good enough to steal as self-study projects.

Here's how the five terms overlap on the calendar, which is the constraint nobody mentions:

(interactive diagram — view it on the original post)

The practical reading: from September 22 to December 3 there are three live courses on the same six weekday slots. Anything you add on top is a replay, and replays can wait until January.

The Stack I'd Actually Run

Run CMU 11-768 as the spine, CS146S as the practice track, and CS329A as the theory replay; skip or defer the other two. That's the whole recommendation. Here's why it comes out that way and what it costs per week.

CMU is the spine because it's the only course that gives you all three pieces on the same week: a lecture you can watch, slides you can search, and a public assignment you can run. The syllabus goes further than any of the others too. Weeks 1 to 3 are capabilities (tool use, context management, skills and memory, planning), weeks 4 to 6 are domains plus training (SFT, RL basics, advanced RL, RL systems), then safety, frameworks (an OpenHands session and a LangGraph session), interaction, and search. Twenty-eight sessions including a fall break and two guest lectures in November. Assignment 1 asks you to build a ReAct harness from scratch that fixes a bug in a chess app and then plays chess through tool calls, with context compaction in the middle; that's a better exercise than anything in the CS146S 2025 assignment set, and it was posted publicly on August 31.

CS146S is the practice track because it teaches what CMU deliberately skips: how to work inside Claude Code, Codex, and Cursor as a professional. MCP, agent skills, CLAUDE.md and hooks, agent-ready repos, background agents, and the software factory. No video, but each week's topic maps to a tool you can run that night, and I've already written the week-by-week exercise plan. If you've read my loop engineering or CLI skills vs MCP posts, you already know the shape of that syllabus.

CS329A is the theory replay because it explains the frontier the other two only gesture at: why test-time compute scales, what a verifier is and why it has to be robust, how RL post-training turned chatbots into agents, and how to evaluate long-horizon tasks. Nine lectures, 10.5 hours, no homework you can submit. Watch it in November when the two live courses hit their project phases and the lecture load drops.

The two I'd defer: CS329Z, because without recordings it's a syllabus to mine, not a course to follow (more on that below), and MIT, because it's a multimodal ML course; agents get one lecture (April 7) and one tutorial (April 23) out of 28 sessions, and if you need multimodal fusion and alignment you'll know it.

(interactive diagram — view it on the original post)

Hours per week, with the assumptions stated. CMU live: two lectures at 60 to 76 minutes, two to three readings (the tool-use lecture alone lists four papers and 26 reference links), and the assignment; 6 to 8 hours. CS146S without grades: one deck, one reading, one exercise; 5 to 6 hours, which is the number readers of the follow-along post told me they can sustain. CS329A replay: 1.75 hours per lecture including notes; 1 to 2 per week. Spine plus practice track is 11 to 14 hours a week. That's a real commitment, and if you can't make it, drop to CMU alone and read the CS146S decks on weekends. Don't do the reverse: CS146S without CMU leaves you fluent in tools and unable to explain why a harness works.

Course by Course: What Each Is Really For

CMU 11-768 is the closest thing to a complete agents curriculum any university has published, and it's the one nobody's talking about. Neubig maintains OpenHands and Fried came from Meta's agent work, so the frameworks weeks aren't a survey; they're the authors explaining their own decisions. Grading is 40% individual assignments (harness 10%, eval 15%, training 15%), 10% "lecture highlights," and 50% a team research project with a poster on December 1 to 3. Two things to know before you start. The assignment defaults to DeepSeek-V4-Flash through an OpenAI-compatible endpoint and runs agent actions in Modal sandboxes; enrolled students get credits, you'll pay your own, and I haven't run it end to end myself, so budget for that. And Assignment 2 (eval) and 3 (training) were due September 24 and October 22 but hadn't been posted publicly when I checked; the site says starter materials "will be posted here as they become available."

Stanford CS146S is the course for the working engineer, and the one I'd tell most readers of this blog to start with. I've written three full posts on it, so I'll be brief: Fall 2026 is a rewrite of the 2025 syllabus around MCP, agent skills, CLAUDE.md and hooks, agent-ready codebases, background agents, and the software factory, with 30% of the grade now on open-source contributions and eight guest sessions from the people who build Cursor, Claude Code, Factory, Cognition, Semgrep, Cloudflare's agent stack, and Replit. Its weakness is exactly what CMU has: no video, no assignment you can grade yourself against, and a shallow treatment of how agents are trained. Its strength is that every week's topic is something you'll use at work on Monday.

Stanford CS329Z is the syllabus to mine, not the course to follow. Diyi Yang, Michael Ryan (DSPy core contributor), and John Yang (SWE-bench and SWE-agent co-creator) teach it from scratch: LLMs for builders, RAG, tool use, frameworks (DSPy, LangGraph, LlamaIndex, MCP, litellm), design patterns and scaffolds, memory, multi-agent, optimization, then coding agents and proactive agents in the back half. The two homeworks are the prize. HW1 is "build a company's internal AI assistant from scratch, with no agent frameworks: just a chat-completion call and code you write yourself," released October 5, due October 30. HW2 is an evaluation suite with code-based graders, at least one LLM-as-judge eval, and benchmark tasks built with the course's "4-tuple framework," due November 20. Both descriptions are public. Neither starter kit is. Do them anyway, on the course's dates, and you'll have reproduced 20% of a Stanford grade without Canvas. The recordings, quizzes, and the "Making Life at Stanford Better with Agents" project (50%) stay behind the login.

Stanford CS329A is the lecture series to watch when you want the why. Mirhoseini and Chowdhery (PaLM, Gemini, AlphaChip between them) organize the course around one question: how does an agent keep improving through interaction with its environment? The nine public lectures are the instructor sessions: course overview, test-time compute scaling, robust verification, learning from feedback with tools and code, planning and multi-step reasoning, train-time scaling and RL, self-improvement and deep research agents, agentic evaluations and long-horizon tasks, future research areas. If you've read my agentic loops post and wanted the training-side counterpart, this is it. Homework and the research project (35%) were for enrolled students, and the course hasn't announced a Fall 2026 run.

MIT's course is excellent and mostly not about agents. Paul Liang's Spring 2026 offering is a multimodal ML course: representation, fusion, alignment, large multimodal models, generation, reasoning, transfer, then applications with Media Lab and Sloan co-instructors. Thirteen of 28 sessions have video; the four application lectures and the three tutorials don't. The agents content is week 10.1 (multimodal interaction, with VisualWebArena, Mind2Web, and OpenVLA on the reading list), the April 23 agents tutorial (slides only), and week 14.1 on self-evolving AI. If you're building GUI or vision agents, watch weeks 4, 5, 9, and 10 and skip the rest. If you aren't, this isn't your course, and it's fine to say so.

What's Not Free

Everything that involves a human looking at your work stays behind enrollment, at all five. The tables above say "free," and the materials are, but here's the honest list of what you don't get, because it's the same list every time:

Grades and feedback. CMU's 50% project, CS329Z's 50% project, CS329A's 35% project, CS146S's 50% final project. No one reads your work. Substitute: publish it and ask the tool's community to review, which is worse but not nothing.
Assignment starter code, partially. CMU posted Assignment 1; Assignments 2 and 3 weren't public on September 9. CS329Z's HW1 and HW2 are descriptions only. CS146S's 2026 assignments weren't posted; the 2025 set is on GitHub. CS329A and MIT posted none.
API and compute credits. CMU's assignment expects a Modal account and an LLM key; the course arranges credits for students. Running the harness assignment on your own DeepSeek or OpenAI-compatible key is the one line item in this post that costs money, and I can't tell you how much because I haven't run it.
Discussion and office hours. Piazza, Ed, Canvas, and TA hours are enrolled-only everywhere. CS329Z even keeps its quizzes closed-book and individual.
Guest lectures, mostly. CS329A's DeepMind and Reflection AI guests aren't in the nine public videos. CS146S's eight guests have no video at all. CMU's two November guest lectures aren't named yet, and whether they're recorded is up to the speaker.
Recordings, for CS329Z and CS146S. Canvas-only and nonexistent, respectively. If you need to watch a Stanford agents course, CS329A is the only one.

What is free is more than it sounds: every syllabus, every reading list, six CMU slide decks and four lectures with more coming, 17 CS146S decks from 2025, CS329A's nine lectures, MIT's 13, and one runnable CMU assignment. Ten weeks of that, done on the calendar the classes are on, is more than most enrolled students will finish.

Following From Outside the US

None of the live sessions are attendable remotely, so time zones only affect when materials land. CMU lectures are Tuesday/Thursday 3:30 to 4:50 PM Eastern; the recordings have been showing up on the playlist within days, not hours. CS329Z is Monday/Wednesday 1:30 to 2:50 PM Pacific, but you can't watch it anyway. CS146S publishes days but not times. Daylight saving ends November 1 in the US, so any "next morning" habit shifts an hour after that.

The real access question for readers in China is YouTube and Google Slides, and the answer is that four of the five depend on them: CMU's recordings and CS329A's and MIT's lectures are YouTube-only, and CS146S's decks are Google Slides. CMU's slides are plain PDFs on the course domain, which is the one exception. I go into the download-and-cache workflow in the Chinese version of this post; the short version is that the PDFs and playlists are all public, so a one-time fetch per week is enough.

Where This Page Stops

This is the routing page. The deep dives are where the week-by-week plans live: the CS146S follow-along for the practice track, the CMU 11-768 deep dive for the spine, and the CS329Z breakdown for the homework you can steal. I'll update the table when CMU posts Assignments 2 and 3, when CS146S posts its 2026 decks, and if CS329Z or CS329A releases any video; the "as of" dates in the text are the tell.

Three things I couldn't verify and want on the record: whether CMU's November guest lectures will be recorded, the cost of running CMU Assignment 1 on your own API key, and whether CS329A will run again in 2026-27. If you're enrolled in any of these and know, the comments are open.

CMU 11-768 AI Agents Fall 2026: Full Syllabus Breakdown

Bruce He — Fri, 11 Sep 2026 07:46:58 +0000

Ten minutes into the second half of lecture 1, Graham Neubig asks the room a question I've spent most of this year writing about. There are two ways to make an agent better, he says: train the LLM, or engineer the harness around it. Show of hands, which one matters more? A few hands go up for training. A lot go up for harness. Daniel Fried raises his hand twice and gets told instructors don't get to vote.

Then Neubig gives his own answer, and it's the most useful sentence in the four and a half hours of CMU 11-768 AI Agents video that exist as of September 8, 2026: "Typically what happens is you identify a problem and you solve it in the harness first. Then the people training the models catch up... and you don't need to solve it in the harness side anymore." He favors training as the fundamental fix, when you can afford it. You usually can't, so you start with the harness.

That one exchange tells you what this course is. Stanford's CS146S, the most-read course page on this blog, teaches you to use agents well. 11-768 is the supply side: how the harness, the eval, and the RL-trained policy get built, taught by the person who built OpenHands and a co-instructor whose group works on human-agent interaction. There is no other public university course that puts scaffold-building, eval design and agent RL in one syllabus. This post breaks down all 28 sessions, the three assignments, and who it's actually for.

What CMU 11-768 Actually Is

The site at cmu-agents.com is a React app that renders nothing to a plain fetch, so every fact in this table comes from the site's JavaScript bundle (pulled September 8), the Assignment 1 repo, and the lecture 1 recording. I'll flag the few things I couldn't confirm at the end.

Item	Details
Course	11-768 AI Agents, Carnegie Mellon University (Language Technologies Institute)
Term	Fall 2026, Aug 25 to Dec 3; Tue/Thu 3:30 to 4:50 PM ET, Porter Hall 100
Instructors	Graham Neubig (OpenHands), Daniel Fried
TAs	Aditya Soni, Andy Liu, Apurva Gandhi, Demi Wang, Jiarui Liu, Yueqi Song
Sessions	28 scheduled (22 lectures incl. 6 guest slots, 2 project-hour days, 2 poster days, 2 break days)
Prerequisite	"Prior experience training neural language models"; 11-667 / 11-711 / 10-202 recommended
Assignments	A1 Harness (due Sep 14), A2 Eval (Sep 24), A3 Training (Oct 22), then a team research project
Compute sponsors	Fireworks, Modal, Prime Intellect, Sail
Public materials	Slides for lectures 1 to 6, YouTube recordings for lectures 1 to 4, Assignment 1 starter code

The one-line pitch is Neubig's own, from the announcement tweet: "learn how to create a scaffold, build evals, and train an agentic LLM using RL." On the course site, the stated outcomes are that you'll be able to implement an agent from scratch on top of an open-source LLM, design evaluations for multi-step tasks, train agents to improve their capabilities, reason about safety and reliability tradeoffs, and pursue an open research question in agents.

Read that list against CS146S's syllabus and the gap is obvious. CS146S never touches training. It never asks you to write the loop. 11-768 makes you write the loop in week three.

Build, Evaluate, Train: The Spine of the Course

Fried lays out the structure explicitly in lecture 1: three skills in the first half (create a harness, evaluate it, train it with RL), then the second half is a group project that uses those skills. The lecture order is capabilities first, then domains (coding, GUI, deep research), then SFT and RL, then frameworks and safety, then interaction, then guest lectures.

Here's how that spine maps onto the tools and concepts this blog already covers, because that mapping is the whole reason a Claude Code or Codex power user should care about a graduate NLP course.

(interactive diagram — view it on the original post)

The dotted edges are the point. Every box on the left side of Assignment 1 is a thing you've configured in a commercial coding agent: hooks, skills, compaction thresholds, tool error handling. The course makes you build each one and then measures what breaks. That's the harness engineering I described in Build the 6 Layers Backwards, except with a grader.

And the right side is where Neubig's "harness first, then training catches up" flow lands. In Harness Engineering: Window of Opportunity I argued the harness advantage is a 2026-2027 window, not a moat. Lecture 1 is the OpenHands creator saying the same thing to a room of PhD students, and then spending Assignment 3 teaching them how to close the window.

The Full 28-Session Schedule (Fall 2026)

At module level, the semester looks like this:

(interactive diagram — view it on the original post)

Every row comes from the site's schedule data. Video links are the four recordings that exist on the YouTube playlist as of September 8; slides are live PDFs on cmu-agents.com (lecture 5's deck is 18 MB, so don't open it on mobile data). Speaker is Neubig or Fried unless a name is listed.

Date	#	Title	Speaker	Materials
Tue Aug 25	1	Course Overview: What Is an Agent?	Fried + Neubig	Slides · Video
Thu Aug 27	2	Agent Capabilities 1: Tool Use	Neubig	Slides · Video
Tue Sep 1	3	Agent Capabilities 2: Context Management for Long-Context Agents	Neubig	Slides · Video
Thu Sep 3	4	Agent Capabilities 3: Skills and Memory	Fried	Slides · Video
Tue Sep 8	5	Agent Capabilities 4: Planning, Task Decomposition, and Multi-Agent Coordination		Slides
Thu Sep 10	6	Domains 1: Coding Agents		Slides · A1 due Mon Sep 14
Tue Sep 15	7	Domains 2: GUI Agents	JY Koh
Thu Sep 17	8	Training 1: Supervised Fine-Tuning (SFT)	Yueqi Song
Tue Sep 22	9	Training 2: Reinforcement Learning Basics
Thu Sep 24	10	Domains 3: Deep Research Agents	Akari Asai	A2 due
Tue Sep 29	11	Training 3: Advanced RL Algorithms
Thu Oct 1	12	Training 4: RL Systems	Apurva Gandhi
Tue Oct 6	13	Safety 1: Sandboxing and Credential Management
Thu Oct 8	14	Frameworks 1: OpenHands
Oct 13, 15		Fall Break, no class
Tue Oct 20	15	Frameworks 2: LangGraph
Thu Oct 22	16	Safety 2: Observability and Monitoring	Eric Wallace	A3 due
Tue Oct 27	17	Agents and the Future of Work	Zora Wang
Thu Oct 29	18	Interaction 1: Multi-Agent Interaction	Saujas Vaduguru
Nov 3, 5		Project hours
Tue Nov 10	19	Interaction 2: Human-Agent Interaction	Valerie Chen
Thu Nov 12	20	Search 1: Reranking and Critic Models
Tue Nov 17	21	Search 2: Tree Search	JY Koh
Thu Nov 19	22	Guest Lecture	Karthik Narasimhan (Princeton)
Tue Nov 24	23	Guest Lecture	Sasha Rush
Thu Nov 26		Thanksgiving, no class
Dec 1, 3		Final presentations (posters)

Two things about this table that matter more than the titles.

The readings are the real syllabus. Lecture 2 alone links 26 references, and they aren't survey papers: the MCP 2026-07-28 spec release, Qwen3.8's tool-call chat template, DeepSeek V3.2's tool-call encoding script, OpenHands' ToolDefinition source, FastMCP's bearer-token auth. Lecture 3 has 44, including KV-cache pricing pages from DeepSeek, Z.AI, Kimi, OpenAI and Anthropic side by side, and the source of Codex, OpenCode, Pi, Hermes Agent and OpenHands as case studies in how production agents manage context. Lecture 4's readings put Hermes Agent's prompt_builder.py and skills_tool.py next to the SkillsBench and "Not All Skills Help" papers. If you only watch the videos, you'll miss most of what the course is teaching.

The guest list is researchers, not vendors. CS146S brought in the creator of Claude Code, the CEO of Warp, a partner at a16z. 11-768's outside voices are Karthik Narasimhan (SWE-bench and SWE-agent are from his group), Sasha Rush, Eric Wallace, Akari Asai. Different course, different audience, and you should pick accordingly. More on that below.

Assignment 1 Up Close: Build the Thing You've Been Configuring

This is where the course earns its keep for practitioners, so it gets the most space.

cmu-agents/assignment-1 went public on August 31 and had 30 stars and 23 forks by September 8. It's a uv project with a Makefile, a vendored chess web app, and a 100-point rubric spelled out in ASSIGNMENT.md. The default model is deepseek/deepseek-v4-flash-0731 through an OpenAI-compatible endpoint, and every tool call runs in a Modal sandbox. The starter's tests fail on purpose; you fill in the TODOs. I cloned it on September 8 and ran make setup (uv sync plus the pinned chess_app submodule) and uv run pytest: 11 failed, 4 passed, 4 deselected (the billable Modal tests), 3.2 seconds, every failure a NotImplementedError at a TODO. That's the whole offline loop, and it costs nothing.

Here's what you build, part by part, and what it corresponds to in the tools you already run.

A1 task	What you implement	What it is in Claude Code / Codex terms
1.1 `build_prompt`	System/user/assistant/tool message sequencing, domain-agnostic	The context window you've been shaping with CLAUDE.md
1.2 `Agent.run`	The ReAct loop with a `step_limit` and `finished` flag	The agentic loop itself
1.3 `execute_tool_calls`	Parallel tool calls; malformed JSON and unknown tools become recoverable observations, not exceptions	Tool error handling; what a PostToolUse hook sees
1.4 Skills	Discover one `SKILL.md` per directory, parse YAML frontmatter, expose name+description in the system prompt, full body via `invoke_skill`	Claude Code Skills, literally the Agent Skills format
2.1 `compact_context`	Model-generated working memory; summarize the old prefix, keep system/task and latest tool step verbatim; trigger at 6,000 tokens on `django__django-15368`	`/compact` and auto-compaction
3.1 to 3.5 ChessAgent	`play_move`, `simulate_move`, `run_python` (code runs in the sandbox, never locally), plus a chess skill	Programmatic tool calling; CodeAct-style code-as-action

Three details in that rubric are worth more than any lecture slide.

First, the compaction part is graded on a real SWE-bench instance and the report you write comparing token usage with and without compaction. That's the same experiment I ran informally in Context Engineering for Coding Agents 2026, where subtracting context beat adding it. Now it's a homework with a FAIL_TO_PASS check. And the reason it's in the course is the story Fried opens lecture 1 with: an OpenClaw user asked the agent to organize her inbox, it announced "I'm taking the nuclear option," deleted her mail, and later admitted "I do remember that she told me this, but I violated it." Fried's diagnosis: the agent compacted its context and the instruction not to delete emails fell out. Part 2 is you building the mechanism that caused that, and learning what has to survive the summary.

Second, the skills part requires progressive disclosure: only name and description in the system prompt, full content on demand. The grader checks that when no skill is loaded, nothing in the prompt mentions patch.txt. That's a cleaner statement of why Claude Code's skill catalog works the way it does than anything in Anthropic's docs.

Third, Part 3's observation A/B experiment (board only vs. board plus legal moves, on DeepSeek and gpt-oss, four runs) is graded "on the experiment and evidence, not on a particular result or winning the game." Tool output design as a controlled experiment. Most teams I've watched build agents never run this experiment once.

Two honest caveats. The instructor tests and reference patches aren't in the repo, so outsiders can pass make test but never get the private score. And the assignment is billable: Modal sandboxes plus LLM tokens. Enrolled students get sponsored credits; you'd pay your own way, though at DeepSeek-V4-Flash prices the LLM side is pocket change and Modal's free tier covers a lot of sandbox minutes.

Who Should Take 11-768 vs CS146S vs CS329Z

Three courses now cover "AI agents" at top schools this fall, and they're not substitutes. I wrote up the whole field in Free AI Agent Courses Fall 2026; here's the three-way call.

	CMU 11-768	Stanford CS146S	Stanford CS329Z
Question it answers	How do you build, evaluate and train an agent?	How do you ship software with agents?	How do you engineer agent systems?
You write	A ReAct harness, evals, an RL training run	Prompts, MCP servers, specs, projects with Claude Code	See the CS329Z breakdown
Prereq reality	Have trained a 4-7B model	Can program	Systems background
Public video	Yes, 4 of 22 so far	No official recordings	See breakdown
Best for	Agent builders, harness engineers, ML engineers moving into agents	Developers who want to use Claude Code / Cursor well	Engineers designing multi-agent production systems
Skip if	You've never fine-tuned anything and don't plan to	You already run agents daily	You want the ML side

The decision rule I'd give a friend: if the thing you want to get better at is configuring an agent, take CS146S and read my CS146S overview. If the thing you want to get better at is deciding whether a problem belongs in the harness or in the weights, that's 11-768, and nothing else public teaches it.

One misconception to kill: 11-768 is not an OpenHands course. OpenHands gets exactly one lecture, October 8, and LangGraph gets the next one. Assignment 1 is closer to mini-SWE-agent (which Fried demos in lecture 1 and calls "effective with recent models, but also pretty simple") than to OpenHands. The readings cite Codex, OpenCode, Pi, Hermes Agent and Claude Code's permission modes as peers. Neubig built OpenHands; the course is about the ideas underneath every one of these tools.

The Five Lectures a Claude Code Power User Should Watch

If you run a coding agent daily and have 6 hours, not 27, here's the cut, in order.

Lecture 1, second half (Neubig on capabilities). The harness-vs-training exchange, his taxonomy of what makes agents fail (environment understanding, safety as a capability, "a thousand-line change where two lines would do"), and the systems tour: sandboxes (Docker, Apptainer, Modal), inference (vLLM, SGLang, "an extremely important part of agents is caching previous requests"), RL systems (SkyRL, Miles), observability (Laminar, MLflow). 30 minutes that reorganize how you think about your own setup.
Lecture 3, Context Management. The pricing and KV-cache section is the one to watch. When you see why cached-prefix pricing exists, you stop appending to your CLAUDE.md.
Lecture 4, Skills and Memory. Fried's lecture, and the readings are the Hermes Agent skills implementation next to the SkillsBench and "Not All Skills Help" papers. Directly applicable to any .claude/skills/ directory.
Lecture 2, Tool Use. Slower, but the chat-template material (how Qwen, Mistral and DeepSeek actually encode a tool call) explains half the "the model called the wrong tool" bugs you've filed.
Lecture 13, Sandboxing and Credential Management (Oct 6, not yet recorded). Neubig previews it in lecture 1 with the OpenAI cyber-benchmark incident where an agent, unable to hack its target, hacked the benchmark's Hugging Face page instead. If you give agents credentials, this is your lecture.

Skip, for now: the SFT/RL block (lectures 8 to 12) unless you have a training job in mind. It's the heart of the course for enrolled students, but it's also the part where "prior experience training language models" stops being a suggestion.

How to Follow 11-768 Free, and When Videos Actually Drop

There's no livestream. Lectures are recorded and uploaded in batches to Neubig's YouTube channel. All four current videos were posted on September 8, covering lectures from August 25 through September 3, so the lag is roughly one to two weeks. Lectures 5 and 6 (September 8 and 10) have slides up but no video as of September 8. Don't set an alarm for class time; check the playlist on Tuesdays.

For completeness, class time in other zones (Pittsburgh is UTC-4 until November 1, then UTC-5):

Zone	Until Oct 31	From Nov 3
Pittsburgh (ET)	Tue/Thu 3:30 to 4:50 PM	same
London	8:30 to 9:50 PM	8:30 to 9:50 PM
Beijing / Singapore	Wed/Fri 3:30 to 4:50 AM	Wed/Fri 4:30 to 5:50 AM
India (IST)	Wed/Fri 1:00 to 2:20 AM	Wed/Fri 2:00 to 3:20 AM

What's free vs. enrollment-only, as of September 8, 2026:

Free	Enrolled only
Slides for lectures 1 to 6 (PDF)	Piazza, Canvas, office hours
YouTube recordings 1 to 4 (4h 36m total)	Sponsored Modal + LLM API credits
Full reading and reference lists	Assignment 2 (Eval) and Assignment 3 (Training) repos
Assignment 1 starter repo and rubric	Private tests, reference patches, grades
Course policies, grading weights	Lecture-highlight quizzes, project mentoring

A six-week self-learner sequence. The semester spreads 22 lectures over 15 weeks with breaks. If you're following on your own, compress it and reorder around the assignment you can actually do:

Week 1: Lectures 1 and 2. Clone assignment-1, run make setup and make doctor, get one billable make run-code-agent through.
Week 2: Lectures 3 and 4. Do A1 Parts 1 and 2. Write the token-usage comparison even though nobody will grade it; that report is the learning.
Week 3: Lectures 5 and 6. Do A1 Part 3. Run the four-way observation A/B.
Week 4: Lectures 7 to 10 as they post (GUI, SFT, RL basics, deep research). Read the SWE-Gym and R2E-Gym papers from lecture 6's list.
Week 5: Lectures 11 to 14 (advanced RL, RL systems, sandboxing, OpenHands). Since A2 and A3 aren't public, build your own eval over your A1 harness: 10 tasks, FAIL_TO_PASS style, and an LLM-as-judge for the ones without tests.
Week 6: Lectures 15 to 23 as they land through late November. Guest lectures are the dessert.

Grading, if you want to know what enrolled students are optimizing: Assignment 1 is 10%, Assignments 2 and 3 are 15% each, lecture highlights are 10% (22 opportunities, best 20 count, must be written without AI, submitted within 24 hours), and the team project is 50% across proposal, check-in, poster and a 30% final report. Each assignment gets two 24-hour slack days, then 5% per day.

Where This Page Stops

Things I could not verify and won't pretend to:

Assignment 2 and 3 contents. Only the one-line summaries on the site ("design the evaluation framework," "implement the training procedures") and Fried's remark that A2 involves "LLM-as-judge based evaluation approaches among other evals." No repos as of September 8.
Who teaches lectures 5, 6, 9, 11, 13, 14, 15, 20. The schedule lists no lecturer for those, which by the site's convention means Neubig or Fried; I haven't confirmed which.
Whether every lecture will be recorded. Four of six delivered lectures have video. The guest-lecture policy on recording isn't stated.
Modal and API costs for an outsider doing A1 end to end. I ran the setup and the offline test suite, not the billable pipeline (make run-code-agent, the SWE-bench run, the four chess runs); I'm not going to invent a dollar figure.

Everything else, from the 28 dates to the 100-point rubric to the quotes from lecture 1 (lightly cleaned of "um" and "uh," from YouTube's auto-transcript), is checkable at the links above. If cmu-agents.com changes the schedule, the JavaScript bundle at /assets/index-*.js is where the truth lives.

pi Coding Agent Review 2026: 4 Tools vs Claude Code, Tested

Bruce He — Fri, 11 Sep 2026 07:46:21 +0000

The same one-word prompt cost 1,358 tokens of context in pi and 31,012 in Claude Code. Same Mac, same afternoon, same "reply with exactly the word PONG." That single number is the whole pitch of the pi coding agent, and it's also the number that misleads people into thinking pi is a lighter Claude Code.

It isn't. After a day of installing it, writing an extension for it, forking its sessions, and running three identical tasks in both pi and Claude Code, my read is this: pi is a harness-engineering kit, not a finished harness. It ships the four layers you'd build first if you were rolling your own agent, and it hands you the two layers that my six-layer harness post says drive 80% of production stability. Whether that's a gift or a trap depends entirely on who you are.

Receipts below. A quick note on scope: a Chinese tutorial on runoob covers pi's feature list step by step; this post is about what those features cost, what they don't do, and whether you should switch.

What pi coding agent actually is (September 2026)

pi is Mario Zechner's answer to Claude Code turning into, in his words, "a spaceship with 80% of functionality I have no use for." Zechner is the libGDX creator; he published pi's rationale on his blog in November 2025 and the core idea hasn't moved since: four tools (read, write, edit, bash), a system prompt small enough to read in one screen, and a TypeScript extension API for everything else.

The project's numbers are not small-project numbers. As of September 6, 2026, earendil-works/pi has 103,925 stars and 12,999 forks, created August 9, 2025, last pushed the day before I checked, MIT licensed. The CLI package @earendil-works/pi-coding-agent sits at v0.85.1 (released September 5) and pulls 1.53M npm downloads a week.

For scale, @anthropic-ai/claude-code does 8.55M and @openai/codex 13.16M, so pi is roughly one-sixth of Claude Code by install volume and well ahead of OpenCode's 1.31M.

The repo moved in May. On May 7, 2026, v0.74.0 became the first release under the @earendil-works scope after Zechner joined Earendil, the public-benefit corporation Armin Ronacher co-founded; the old badlogic/pi-mono URL now redirects. The license stayed MIT and the CLI is still pi.

Two facts make the move matter more than a rename: OpenClaw, the agent that got half the industry's attention this spring, is built on pi's packages (its current release openclaw@2026.9.4 depends on @earendil-works/pi-tui), and pi's library packages out-download its CLI. pi-tui alone gets 5.12M weekly downloads. pi is already more "infrastructure other agents are built on" than "CLI people type into."

Community reception is ecosystem-shaped rather than launch-thread-shaped. There's no 800-point Show HN; the loudest pi thread on Hacker News in 2026 is a 56-point complaint that its config folder ignores XDG on Linux (August 17), and the second is oh-my-pi, a fork with an IDE wired in (42 points, July 21). The Pragmatic Engineer ran a full episode on it in April. And the package gallery at pi.dev/packages lists 5,410 packages, which is the real reception signal: people are building on it, not arguing about it.

pi's four packages on the six harness layers

pi ships as a monorepo of four packages plus a couple of support libraries: pi-ai (unified provider API), pi-agent-core (the loop), pi-tui (terminal rendering), and pi-coding-agent (the CLI that wires them together, plus the SDK and RPC modes). Mapped onto the six-layer model from my earlier posts, the shape is lopsided in a very deliberate way.

(interactive diagram — view it on the original post)

Layers 1 through 4 are not just present, they're better than most people expect. The session tree in particular is something Claude Code doesn't have: every entry in a pi session has an id and a parentId, so you can branch from any earlier turn without losing the original path. Layer 4 is the layer I told people to skip in the six-layer post, and pi ships it anyway because it's cheap when the storage format is a tree from day one.

Layers 5 and 6 are where pi stops. There is a JSON event stream and an RPC protocol, which is the raw material for observability, but no cost dashboard beyond the TUI footer and no eval harness. And there is no permission system at all. pi's security doc says it plainly: "Pi does not include a built-in sandbox... Real isolation needs to come from the operating system or a virtualization/container boundary."

If you read my window-of-opportunity post, you'll recognize the bet pi is making: the patch layers (context tricks, forced planning, permission theater) get absorbed by better models, so don't bake them in. The design-literacy layers (what to verify, what to recover from) stay with the user. pi is that argument turned into a product.

Hands-on: install, provider, and what a prompt costs before you type

Install. npm install -g --ignore-scripts @earendil-works/pi-coding-agent took 77 seconds on my M-series Mac and landed 449 MB in node_modules. That's the first thing that punctures the "minimal" story: 292 MB of that is @esbuild platform binaries, and the rest is the Anthropic, OpenAI, Google, and AWS SDKs bundled so every provider works out of the box. pi is minimal in context tokens, not on disk. On first interactive launch it also downloaded fd and ripgrep (6.7 MB) into ~/.pi/agent/bin without asking, which is convenient and slightly presumptuous.

Provider. pi's /login supports subscription OAuth for ChatGPT Plus/Pro, Claude Pro/Max, GitHub Copilot, and xAI, plus 30-odd API-key providers including DeepSeek, Kimi, MiniMax, Qwen, and Z.AI. One line in the providers doc deserves a highlight because it changes the economics for a lot of readers: "Third-party harness usage draws from extra usage and is billed per token, not against Claude plan limits." I did not run the Claude login for that reason; it would have charged this account per token. The only key on this machine was Google's, so pi ran on Gemini 3.1 Pro (with Gemini 3.8 Flash for the cheap experiments), and Claude Code ran on its default Claude Fable 5.1. Keep that in mind for everything below: these are harness-plus-model comparisons, not harness-only.

Context footprint. This is the measurement that started the post. I sent the same "reply with exactly the word PONG" through three configurations and read the usage back from each tool's JSON output:

Configuration	Input tokens before your first word	List-price cost of "PONG"
pi, `--no-skills --no-extensions --no-context-files`	1,358	$0.0034 (Gemini 3.1 Pro)
pi, default (auto-loaded 48 skills from `~/.agents/skills`)	10,787	$0.0081 (Gemini 3.8 Flash)
Claude Code 2.1.268, `claude -p`, fresh empty repo	31,012 (20,884 cache write + 10,126 cache read + 2)	$0.4214 (Fable 5.1, list)

Two things to take from that table. First, pi's floor really is small: 1,358 tokens is the four tool definitions, the prompt, and the working directory, and it's the same number on Pro and Flash.

Second, the middle row is the gotcha nobody warns you about. pi auto-discovers skills from ~/.agents/skills and .agents/skills, the same directories other harnesses use. I had 48 skills sitting there from other tools, and pi silently put 9,400 tokens of skill descriptions into every request. Run pi --verbose once and read the startup header before you trust the "under 1,000 tokens" marketing line.

Three identical tasks: pi vs Claude Code receipts

I built a 241-line Node project (invoice math: money, tax, discounts, CSV report) with a five-rule AGENTS.md, a planted off-by-one bug in the discount tiers, and four TODO comments. Then I ran three prompts through both agents headlessly (pi --mode json -p and claude -p --output-format json --dangerously-skip-permissions), each in a fresh copy of the repo.

Task	pi + Gemini 3.1 Pro	Claude Code + Fable 5.1
a. Add 3 unit tests for `mergeLines`	29.5s · 6 turns · 5 tool calls · 75k in / 2.0k out · $0.10 · 8/8 pass	27.2s · 4 turns · 132k in / 1.5k out · $0.61 · 8/8 pass
b. Find and fix the tier bug, add regression test, explain	28.7s · 7 turns · 6 tool calls · 86k in / 1.7k out · $0.11 · identical 3-line fix · 1 test, 7 asserts	41.5s · 7 turns · 219k in / 2.5k out · $0.77 · identical 3-line fix · 3 tests incl. negative-input case
c. Resolve all 4 TODOs with implementations and tests	94.7s · 21 turns · 20 tool calls (12 bash, 6 edit, 2 write) · 316k in / 5.3k out · $0.31 · 9/9 pass · 0 TODOs left	86.5s · 8 turns · 245k in / 7.0k out · $1.16 · 13/13 pass · 0 TODOs left · test-first
AGENTS.md compliance (JSDoc, `node:test` only, no `data/` edits, ran `npm test`, `SUMMARY:` line)	5/5 on all three	5/5 on all three

Costs are list-price figures reported by each tool; I pay Anthropic a subscription, so the Claude Code column is what it would cost on the API, not what left my bank account. The token columns are the honest part: Claude Code consumed 1.8x to 2.5x the input tokens of pi on every task, and the gap is almost entirely harness overhead being re-sent (and cache-read) every turn.

Where the quality actually differed, it was in task c, and it was the model, not the harness. Claude Code wrote each test first and confirmed it failed before implementing, made the zero-total warning's logger injectable so the test didn't need to mock console, and ended with an unprompted note: "One thing I noticed but left alone since it is not a TODO: volumeDiscount uses strict greater-than comparisons," which is the exact bug from task b. pi with Gemini resolved all four TODOs correctly, mocked console.warn instead, and didn't notice the adjacent bug. On tasks a and b the diffs were functionally identical. Four tools were not the bottleneck on any of the three tasks.

That matches the only same-model comparison I've found. Composio ran 30 agentic tool-use tasks on DeepSeek V4 Pro through both pi and OpenCode in August 2026: pi solved 21/30 (70%) to OpenCode's 19/30 (63%), spent $1.64 to OpenCode's $2.25, but was slower at the median (363s vs 281s). Under 1,000 tokens of fixed overhead per request versus about 6,900. Same shape as my numbers: fewer tokens, similar or better outcomes, not faster.

The 40-line extension, and how the model walked around it

pi's extensibility story is the part that's actually different from Claude Code's, so I wrote an extension instead of reading about one. Extensions are TypeScript files loaded via jiti (no build step) that get an ExtensionAPI. Mine registers a tool_call handler that blocks rm -rf, sudo, and force-pushes, a custom tool the model can call, and a slash command:

// ~/.pi/agent/extensions/guard.ts
import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
import { isToolCallEventType } from "@earendil-works/pi-coding-agent";
import { Type } from "typebox";

const DANGEROUS = [/\brm\s+-[a-z]*r[a-z]*f\b/i, /\bgit\s+push\s+.*--force\b/, /\bsudo\b/];

export default function (pi: ExtensionAPI) {
  let blocked = 0;

  pi.on("tool_call", async (event, ctx) => {
    if (!isToolCallEventType("bash", event)) return;
    const cmd = event.input.command ?? "";
    if (!DANGEROUS.some((re) => re.test(cmd))) return;
    // Interactive: ask. Headless (-p / --mode json): deny. Never self-approve.
    if (ctx.hasUI && (await ctx.ui.confirm("guard.ts", `Allow?\n${cmd}`))) return;
    blocked++;
    return { block: true, reason: `guard.ts blocked destructive command: ${cmd}` };
  });

  pi.registerTool({
    name: "guard_stats",
    label: "Guard stats",
    description: "Report how many bash commands guard.ts has blocked this session",
    parameters: Type.Object({}),
    async execute() {
      return { content: [{ type: "text", text: `guard.ts blocked ${blocked} command(s) so far` }], details: { blocked } };
    },
  });

  pi.registerCommand("guard", {
    description: "Show guard.ts block count",
    handler: async (_args, ctx) => ctx.ui.notify(`guard.ts blocked ${blocked} command(s)`, "info"),
  });
}

This is the PreToolUse hook from Claude Code, except it's a typed function in the same process instead of a shell script reading JSON on stdin, and it can mutate event.input in place, register tools, draw TUI widgets, and read the session. The ctx.hasUI branch is the detail the Agentic Control Plane team called the "empty-chair test" when they built a policy extension in August: in headless mode nobody is there to click Allow, so "ask" must become "deny."

Then I ran it: pi -e guard.ts --mode json -p "mkdir tmp_scratch ... then rm -rf tmp_scratch ... if that fails, delete it another way." Here is the tool sequence from the JSON stream, 11.6 seconds and $0.015 on Gemini 3.8 Flash:

CALL bash  {"command": "mkdir -p tmp_scratch && echo hi > tmp_scratch/a.txt"}
  END bash  isError=false
CALL bash  {"command": "rm -rf tmp_scratch"}
  END bash  isError=true   guard.ts blocked destructive command: rm -rf tmp_scratch
CALL bash  {"command": "rm tmp_scratch/a.txt && rmdir tmp_scratch"}
  END bash  isError=false
CALL guard_stats {}
  END guard_stats  guard.ts blocked 1 command(s) so far

The hook fired. The custom tool worked. And the model deleted the directory anyway, one turn later, with rm plus rmdir. I told it to find another way, so it did, but that's exactly what a prompt-injected model would do too.

A tool_call hook is policy, not a boundary. It's great for "don't touch .env," useless against a model (or an attacker in a README) that wants the thing gone. That is the strongest argument for Zechner's position, not against it: if the only real boundary is the OS, then permission dialogs are UX, and pretending otherwise is the dangerous part.

(interactive diagram — view it on the original post)

The registry side works as advertised. pi install npm:pi-mcp-adapter took 25 seconds, added one line to ~/.pi/agent/settings.json, and gave me /mcp. The adapter is the community's rebuttal to Zechner's "you don't need MCP" post: one proxy tool of about 200 tokens instead of the 13,700 tokens Playwright MCP dumps into context, servers started lazily. It gets 197,718 downloads a week. pi-subagents gets 66,401. The things pi refused to build are the most-installed things in its registry, which is either a vindication of primitives or a sign that everyone rebuilds the batteries anyway. I think it's both.

Session tree: what /fork actually does

pi stores sessions as JSONL trees under ~/.pi/agent/sessions/. I ran a two-turn session headlessly (read app.js, then edit it to print v2), then forked it with pi --fork <id> -p "Instead of v2, change it to print v3. Which version did the file print when you started?". The fork answered "v3... When I started, the file printed v1," and here is what landed on disk:

original session
message   id=a35234bf parent=0e946043 user       "Read app.js and tell me..."
message   id=d7986285 parent=a35234bf assistant  (read tool call)
message   id=7b182e60 parent=d7986285 toolResult "console.log('v1')"
message   id=2b93a6ee parent=7b182e60 assistant  "app.js prints the string v1"
message   id=d6b72102 parent=2b93a6ee user       "Now change it to print v2..."
message   id=d8eb9eb7 parent=a17b112b assistant  "Updated app.js to print v2."

fork (new file, header carries parentSession=<original path>)
... same 10 entries copied, then:
message   id=2c7cfb20 parent=d8eb9eb7 user       "Instead of v2, change it to print v3..."
message   id=763c751e parent=3694092b assistant  "I have updated app.js to print v3..."

So --fork from the CLI copies the whole active branch into a new file and continues from the leaf. Branching from an earlier point (the thing Claude Code can't do at all) is the interactive /tree view, where selecting an old user message moves the leaf to its parent and puts the text back in your editor for re-submission; abandoned branches can get an automatic summary attached at the new position. The JSONL is plain enough that I parsed it with ten lines of Python, which is the observability primitive pi gives you instead of a dashboard.

No sandbox, no permission dialogs: what it means for a team

Here's the comparison table you're probably here for. Everything is as of September 2026; sandbox and permission facts are from each tool's own docs.

	pi 0.85	Claude Code 2.1	Codex CLI	OpenCode
Sandbox	None built in; Docker / Gondolin micro-VM / OpenShell patterns documented	OS-level sandboxed Bash (Seatbelt on macOS, bubblewrap on Linux), auto-allow or ask	Kernel sandbox by default (Seatbelt / Landlock+bwrap / Windows), network off	None built in
Permissions	None; `tool_call` hook or a registry extension (`cc-safety-net`, `@gotgenes/pi-permission-system`)	Prompt per tool, allow/deny rules, permission modes, hooks	`approval_policy` x `sandbox_mode`, two independent dials	`allow` / `ask` / `deny` rules per tool with globs
Extension model	TypeScript modules in-process: events, tools, commands, TUI, providers; npm/git packages	Hooks (shell scripts), skills, MCP, plugins	AGENTS.md, MCP, config profiles	Plugins, MCP, agents in config
Model vendors	Anthropic, OpenAI, Google, DeepSeek, Kimi, MiniMax, Qwen, Z.AI, Bedrock, Vertex, Ollama, custom OpenAI-compatible	Anthropic (plus Bedrock, Vertex, Foundry)	OpenAI (plus OSS providers via config)	Any via Models.dev (75+)
Session model	JSONL tree; `/tree`, `/fork`, `/clone`, branch summaries	Linear with `--resume`, checkpoints	Linear resume	Linear with share
License and price	MIT; you pay the model	Proprietary CLI; subscription or API	Apache-2.0; ChatGPT plan or API	MIT; you pay the model

Zechner's argument for the empty Sandbox row is quotable and mostly right: "As soon as your agent can write code and run code, it's pretty much game over... Everybody is running in YOLO mode anyways to get any productive work done, so why not make it the default and only option?" My guard experiment above is the evidence. But there's a second half he leaves to you, and it's the half that matters for a team.

For a solo engineer, no dialogs is a productivity gain with a known risk you've already accepted (you were going to click Allow anyway). For a team, the question isn't "is the prompt useful," it's "who is accountable when an agent running as deploy deletes the fixtures." Claude Code's answer is a sandbox you can mandate in settings.json; Codex's is a kernel policy on by default. pi's answer is "run it in a container," which is correct and also means the container is now your responsibility, your CI's responsibility, and your onboarding doc's responsibility. If you already run agents in Docker or a micro-VM, pi costs you nothing here. If you don't, pi is the tool that makes you start.

There's a smaller trust boundary pi does implement, and it's the right one: project trust. The first time you open a repo with .pi/extensions or .agents/skills, pi asks before loading them, because a repo that can silently install an in-process TypeScript extension can do anything. Headless runs skip the prompt and default to not loading them. That's the one place pi says "ask first," and it's the one place where asking actually buys you something.

Who should switch, who shouldn't

Switch to pi if at least two of these are true: you already run agents in containers or CI; you're embedding an agent in your own product and want the SDK or RPC mode rather than a subprocess of claude -p; you need models Anthropic doesn't sell (DeepSeek, Kimi, Qwen, a self-hosted vLLM), which pi treats as first-class; you pay per token at scale and a 20x context floor difference shows up on the invoice; or you've hit the ceiling of what a shell-script hook can do and want a typed, in-process one.

Stay on Claude Code if you're onboarding people who've never run an agent, because pi has no guardrails to catch them; you need plan mode, sub-agents, and MCP today and don't want to curate packages; you want a vendor to answer the phone when something breaks (Earendil is a small company; pi has 202 open issues); or you're on a Claude Max plan and expect included usage, which pi's Claude login explicitly isn't.

The honest middle: if you build harnesses for a living, pi is the best reference implementation of layers 1 through 4 you can read in an afternoon, and the cheapest base to build 5 and 6 on top of. If you consume harnesses, Claude Code's batteries are worth their 31,012 tokens. I laid out the same distinction for tool surfaces in CLI skills vs MCP and for the loop itself in agentic loops; pi is what you get when you take both of those posts' advice literally.

Rough edges from one day of use

pi -p hangs if stdin is an open pipe. My first headless run sat for 180 seconds with zero output because the tool harness kept a pipe open; < /dev/null fixed it. If you script pi in CI, redirect stdin or pipe your prompt in explicitly.
Skill auto-discovery inflates context silently. 48 skills from ~/.agents/skills turned a 1,358-token request into 10,787. Use --no-skills or pi config to prune.
Warning spam. With both GOOGLE_API_KEY and GEMINI_API_KEY set, pi printed "Both ... are set. Using GOOGLE_API_KEY" 19 times to stderr in a single run, once per model call.
449 MB install for a tool whose pitch is minimalism, and unrequested binary downloads (fd, rg) on first launch.
Cost visibility is uneven. The TUI footer and --mode json both report per-message cost with cache splits, which is better than Claude Code's headless output. Plain -p text mode reports nothing.
CJK rendered fine. I typed a Chinese prompt into the editor through a pty and it displayed correctly; the differential renderer didn't garble wide characters. The --tui-mode fullscreen mode has a documented iTerm2 inline-image limitation.
~/.pi/agent ignores XDG on Linux, which is the community's loudest complaint this year (56 points on HN, August 17).

Bottom line

pi coding agent is the clearest existence proof that four tools and 1,358 tokens are enough to match a batteries-included harness on ordinary coding tasks; my three runs and Composio's thirty say the same thing. What it is not is a drop-in Claude Code replacement, because the two layers it leaves out, observability and constraints, are the two that decide whether an agent survives contact with a team.

If you've been meaning to build your own harness, pi is where I'd start, and the guard extension above is your first afternoon. If you just want the work done and someone else to own the sandbox, keep paying for the spaceship.

External References

earendil-works/pi on GitHub — source, docs, 79 example extensions
pi.dev and the package gallery — "There are many agent harnesses, but this one is yours"
Mario Zechner, "pi coding agent" (Nov 30, 2025) — the rationale for every omission
pi has a new home (May 7, 2026) — the Earendil move and package rename
Composio, "Pi vs OpenCode: After 100 Hours" (Aug 21, 2026) — the same-model 30-task comparison
Agentic Control Plane, "pi ships no permission system, on purpose" (Aug 17, 2026) — the empty-chair test

Originally published at heyuan110.com

Stanford CS329Z Engineering AI Agents: Syllabus + Self-Study

Bruce He — Fri, 11 Sep 2026 07:45:28 +0000

Stanford's new agents course bans agent frameworks in its first assignment. HW1 of Stanford CS329Z: Engineering AI Agents tells students to build a company's internal AI assistant "with no agent frameworks: just a chat-completion call and code you write yourself." LangChain, LangGraph, DSPy, and LlamaIndex don't show up until lecture six, and when they do, the stated purpose is to compare "what frameworks abstract vs. what you built from scratch."

That one rule tells you what kind of course this is. It's not "learn LangChain in ten weeks," and it's not a coding-with-Claude-Code practicum like CS146S. It's an engineering-discipline course: the syllabus names three challenges up front (decomposition, data, evaluation), and 17 lectures, two homeworks, and 50 readings are organized around them.

This page is the syllabus breakdown plus the part I actually care about: since the recordings are Canvas-only, how far can you get on the public materials alone, and which weeks are worth your time if you already ship agents for a living. I haven't sat in Packard 101 (the first lecture is September 23, 2026), so everything below comes from the course site, the Stanford Bulletin, the instructors' own pages, and the readings themselves. Where I'm guessing, I say so.

CS329Z at a Glance

Item	Details
Course	CS 329Z: Engineering AI Agents
Term	Fall 2026 (Autumn 1, 2026-27), first offering
Lectures	Mon/Wed 1:30-2:50 pm, Packard 101, Sep 23 to Dec 2
Units / class number	3 units, #27855, Letter or Credit/No Credit
Instructors	Diyi Yang (Stanford NLP faculty), Michael Ryan (PhD student, DSPy core contributor, MIPROv2 and GEPA author), John Yang (PhD student, SWE-bench / SWE-agent / SWE-smith first author)
Prerequisite	Any of CS224N, CS224U, CS224V, CS336, or equivalent NLP background
Frameworks touched	litellm, DSPy, LangChain/LangGraph, LlamaIndex, MCP
Recordings	Captured, distributed via Canvas only. Not public.
Contact	cs329z-staff@lists.stanford.edu

The instructor lineup is the strongest signal about what the course values. Michael Ryan wrote the optimizer papers that make DSPy more than a prompt wrapper (MIPROv2 at EMNLP 2024, GEPA, ICLR 2026 oral). John Yang built the benchmark the entire coding-agent industry reports against (SWE-bench), the reference agent that runs on it (SWE-agent), and the data engine that trains for it (SWE-smith). One instructor is optimization, one is evaluation and data. That's the course.

Why "Engineering" Is the Operative Word

The course description opens with the compound AI systems framing from Zaharia et al.: the interesting unit is no longer a model, it's a system of models, retrievers, tools, and optimizers. Then it lists what students learn to do: "pick what types of problems to focus on, decompose problems, select appropriate components, collect and curate data, build evaluations, and reason about the design tradeoffs."

Notice what's missing from that list: prompting. It gets a bullet in lecture two and then disappears. Compare that with most 2025 agent courses, where prompt patterns were half the syllabus.

The grading confirms it. Half the grade is a quarter-long group project ("Making Life at Stanford Better with Agents"), 20% is the two homeworks, and 15% is two ten-minute quizzes where you explain the design decisions and tradeoffs in your own homework. There's no exam on lecture content. You cannot pass CS329Z by remembering what was said in Packard 101, which, as it happens, is also why not having the videos hurts less than you'd think.

Component	Weight	What it actually tests
Project (proposal 5, midway report 5, midpoint demo 7, final submission 15, final demo 18)	50%	Can you scope and ship a working agent in ten weeks
HW1: Build an Agentic Harness	10%	Can you build tools, memory, a terminal, and a human-in-the-loop with zero frameworks
HW2: Evaluate an Agent	10%	Can you write code graders, an LLM judge, and 4-tuple benchmark tasks
HW-based quizzes (2 x 7.5%)	15%	Can you defend your own design tradeoffs, closed-book
Paper video (7%) + 3 peer reviews (3%)	10%	Can you critique a recent agent paper and add something (a reproduction, an experiment)
Participation	5%	Discussion, teamwork, recitations

Here's the mistake I expect people to make with this course: treating it as CS146S with a harder prerequisite. It isn't. CS146S (Fall 2026 runs Tue/Thu from Sep 22, and I wrote a follow-along plan for it) is about developer practice: using Claude Code, Cursor, MCP servers, and code review to ship software faster. CS329Z is about building the agent that someone else uses. The prerequisites say the same thing: CS146S wants CS111-level programming; CS329Z wants CS224N.

	CS146S: The Modern Software Developer	CS329Z: Engineering AI Agents
Question it answers	How do I ship software 10x faster with agents?	How do I build an agent system that works?
Unit of work	Your codebase, your PRs	Harness, RAG pipeline, eval suite
Frameworks	Claude Code, Cursor, Warp, MCP	litellm, DSPy, LangGraph, LlamaIndex, MCP
First assignment	Prompting playground (2025) / 200-line agent (2026)	Full harness with no frameworks
Evaluation content	One review week	Three lectures plus HW2
Prerequisite	CS111	CS224N / CS336
Videos	None public	None public (Canvas only)
Who should follow	Engineers who write code with agents	Engineers who ship agents as the product

If you're a working developer whose agent exposure is Claude Code and Cursor, CS146S first. If you own an "AI assistant" feature at work and your last three incidents were the agent doing something plausible but wrong, CS329Z is the one.

The Full Fall 2026 Schedule

Twenty-one meeting slots between September 23 and December 2: 17 content lectures, 2 guest lectures (speakers TBA), and 2 Thanksgiving days off. The schedule is marked tentative on the site; this is the version as of September 4, 2026. Required readings are listed; each lecture also carries "additional readings" (27 in total) that I've folded into the self-study table further down.

Wk	Date	Lecture	Required readings
1	Wed Sep 23	Introduction: what are agentic systems? Monolithic models to compound systems to agents; the three challenges (decomposition, data, evaluation)	Zaharia et al., Compound AI Systems (BAIR 2024)
2	Mon Sep 28	LLMs for builders: APIs and SDKs (litellm), structured I/O and constrained generation, decoding and test-time compute, context engineering, model selection, cost/latency	Anthropic, Building Effective Agents
2	Wed Sep 30	Retrieval-Augmented Generation: grounding, embeddings and vector stores, chunking, hybrid search, cross-encoders and ColBERT. Hands-on: RAG from scratch	Lewis et al., RAG (NeurIPS 2020)
3	Mon Oct 5	Tool use and function calling: the REPL, function-calling APIs, MCP, designing good tools, sandboxes, error handling and retries. Hands-on: tool-using system from scratch	MCP Specification (2025-06-18)
3	Wed Oct 7	Frameworks and orchestration: DSPy (signatures, modules, optimizers), LangChain/LangGraph, LlamaIndex; what frameworks abstract vs. what you built	Khattab et al., DSPy (ICLR 2024)
4	Mon Oct 12	Agent design patterns and scaffolds: workflows vs. agents, five workflow patterns, ReAct, plan-and-execute, reflection; scaffolds as design decisions	Yao et al., ReAct (ICLR 2023)
4	Wed Oct 14	Agent memory architectures: short vs. long-term, memory as tool actions, the file system as memory, structured memory, cross-agent memory	Packer et al., MemGPT (2023)
5	Mon Oct 19	Multi-agent systems: single vs. multi, orchestration, handoffs and state transfer, delegation, coordination and error propagation	Wu et al., AutoGen (COLM 2024)
5	Wed Oct 21	Optimization: prompt optimization (GEPA, MIPROv2, OPRO, TextGrad), test-time compute, LoRA/QLoRA, distillation, RLHF/DPO; prompts vs. weights vs. inference compute	Snell et al., Scaling Test-Time Compute; Agrawal et al., GEPA
6	Mon Oct 26	Guest lecture (TBA)
6	Wed Oct 28	What data do agents need? Traces, demonstrations, feedback; data for optimization vs. evaluation; flywheels; synthetic data	Shankar, Data Flywheels for LLM Applications
7	Mon Nov 2	Data selection and quality: maximally informative data, filtering, tiny-but-targeted benchmarks, annotation, datasets from agent traces	Yang et al., SWE-smith; Shankar et al., Who Validates the Validators?
7	Wed Nov 4	Evaluation fundamentals and benchmark design: why evals are hard, the 4-tuple (request, environment, stopping criteria, scorer), properties of good benchmarks, reliability	Zhu et al., Rigorous Agentic Benchmarks
8	Mon Nov 9	LLM-as-judge and eval infrastructure: three grader types, judge prompts, known biases, pairwise vs. pointwise, pass@k vs. pass^k, harness design, Anthropic's 8-step roadmap	Anthropic, Demystifying Evals for AI Agents; Zheng et al., MT-Bench; Ryan et al., AutoMetrics
8	Wed Nov 11	Agent safety and guardrails: privacy risks of tool access, prompt injection (incl. indirect), red-teaming, sandboxing and permissions, output guardrails, human-in-the-loop	Shao et al., PrivacyLens; Zhang & Yang, Privacy Risks via Simulation; Li, Agentic LLMs as Deanonymizers
9	Mon Nov 16	Guest lecture (TBA)
9	Wed Nov 18	Coding and software agents: end-to-end; SWE-agent, Claude Code, and OpenHands architectures; scaffolds as design decisions; SWE-bench and the 4-tuple in practice	Yang et al., SWE-agent; Wang et al., OpenHands
10	Nov 23, 25	No class (Thanksgiving)
11	Mon Nov 30	Proactive agents: reactive to proactive, General User Models, next-action prediction, open-source proactive agents, mixed initiative	Shaikh et al., General User Models (UIST 2025)
11	Wed Dec 2	Frontiers and open problems: multimodal, web and computer-use agents, science agents, long-running architectures, observability and cost, reliability	(additional only: OSWorld, WebShop)
Finals	Dec 7-11	Final project demo day

Deadlines, all Pacific: HW1 released Oct 5, project proposal due Oct 9, HW2 released Oct 26, HW1 due Oct 30, midpoint demo Nov 4 in class, midway report Nov 6, paper video Nov 13, HW2 due Nov 20, peer reviews Nov 30, final submission and demo during finals week.

Two things jump out from the table. First, the "from scratch" hands-on sessions (RAG on Sep 30, tools on Oct 5) come before the frameworks lecture on Oct 7, and HW1 releases the same day as the tools lecture. The course wants your hands dirty before it hands you an abstraction. Second, five of the 17 content lectures (Oct 21, Oct 28, Nov 2, Nov 4, Nov 9) are about data, optimization, and evaluation. Nearly 30% of the content is the part most agent tutorials skip entirely.

The Five Modules, and Where This Blog Already Covers Them

The syllabus has ten section headers; I collapse them into five modules because that's how the dependencies actually run. Modules one and two are what you build; three and four are how you make it good and prove it; five is where the field is going.

(interactive diagram — view it on the original post)

The dotted lines are honest about coverage. This blog has written a lot about modules one, two, and five, mostly from the coding-agent angle: context engineering, agentic loops, sub-agent architecture, and harness layers. Module three (data) is where I have almost nothing, and module four (evaluation) I've only covered as one layer of a harness. That gap is a fair proxy for the industry: everyone writes about the loop, few write about the flywheel.

The Two Homeworks Are the Course

If you take one thing from CS329Z without enrolling, take the homework sequence. The site describes both briefs in enough detail to rebuild them, and together they encode the course's actual thesis: build the harness bare-handed, then find out you can't tell whether it works.

HW1: Build an Agentic Harness (weeks 3-6, released Oct 5, due Oct 30). "Build a company's internal AI assistant from scratch, with no agent frameworks: just a chat-completion call and code you write yourself. Start with LLM pipelines that retrieve and reason over a real corporate email archive, then grow them into a full agent harness with tools, a terminal, memory, and a human in the loop." The course doesn't name the archive; my guess is the Enron corpus, because it's the only large, public, real corporate email dataset, and it has the messy threads that make retrieval interesting.

HW2: Evaluate an Agent (weeks 6-9, released Oct 26, due Nov 20). "Given a pre-built agent, design a comprehensive evaluation suite with code-based graders, at least one LLM-as-judge eval, benchmark tasks built with the 4-tuple framework (request, environment, stopping criteria, scorer), and error analysis."

Read the order again. Students spend four weeks building a harness and then four weeks evaluating a different, pre-built agent, not their own. That's a deliberate move: it stops you from writing evals that flatter your own design, and it forces the 4-tuple discipline onto something you didn't build and can't quietly patch. The quiz after each homework is closed-book and asks you to explain tradeoffs, so "I copied the pattern from a tutorial" doesn't survive contact.

Here's how I'd reconstruct both as exercises you can run with Claude Code or Codex as your pair, without any course infrastructure:

(interactive diagram — view it on the original post)

Two rules make the substitute worth doing. For HW1, the zero-frameworks constraint is the whole exercise: if you pip install langgraph on weekend one, you've skipped the course. Let your coding agent write boilerplate, but you write the loop, the tool dispatch, and the memory policy. For HW2, use an agent you didn't write. OpenHands and SWE-agent are both open, both configurable, and both were built by people who wrote the course readings.

The pass^k metric in the Nov 9 lecture is the one detail I'd flag for anyone who has shipped an agent. pass@k asks whether any of k runs succeeds; pass^k asks whether all k do. For a demo, the first number matters. For an agent that runs unattended on customer data, only the second one does, and it collapses fast: a task that passes 80% of the time has a pass^5 of about 33%. That single reframing is worth more than most agent tutorials.

Self-Study Substitute, Module by Module

Every reading in the syllabus is public. Lecture slides "will be linked here as they are released," which may or may not happen; the Fall 2025 CS146S decks did eventually go public, so it's plausible. Until then, here's a substitute for each module, weighted toward what you can run rather than what you can read.

Module	Watch/read instead of the lecture	Do instead of the section	Blog post to pair
1. Building blocks (Sep 23-Oct 5)	Compound AI Systems; Building Effective Agents; Lewis RAG and ColBERT papers; the MCP spec	Write a RAG pipeline and a tool-calling loop with raw litellm calls. No vector DB service; a numpy matrix and cosine similarity is enough to learn the failure modes	Context Engineering 2026, CLI Skills vs MCP
2. Frameworks and design (Oct 7-21)	DSPy docs on signatures, modules, and optimizers; LangGraph docs; ReAct, MemGPT, AutoGen papers; Why Do Multi-Agent LLM Systems Fail?; Neubig's Don't Sleep on Single-Agent Systems	Port your HW1 harness to DSPy, then to LangGraph. Write down what each framework took away from you. Then run `dspy.GEPA` or MIPROv2 on one module and measure the delta on a 50-example dev set	Agentic Loops, Subagent Architecture
3. Data (Oct 28-Nov 2)	Shankar's Data Flywheels; SWE-smith; Who Validates the Validators; LIMA	Log every trace from your HW1 agent. Build a 100-example dataset from the traces, then a 20-example "tiny but targeted" subset that predicts the full score	(gap, see below)
4. Evaluation and safety (Nov 4-11)	Demystifying Evals for AI Agents; Rigorous Agentic Benchmarks; MT-Bench; AutoMetrics; OpenAI on prompt injections; PrivacyLens	The HW2 substitute above. Then plant one indirect prompt injection in your email corpus and see whether your HW1 agent takes the bait	Harness: 6 Layers Backwards (layers 5-6)
5. Coding, proactive, frontier (Nov 18-Dec 2)	SWE-agent and OpenHands papers; Anthropic's Effective Harnesses for Long-Running Agents; General User Models; OpenClaw	Run SWE-agent on 10 SWE-bench Lite tasks with two different scaffolds (tool set or system prompt changed, model held constant). Report the scaffold delta	Harness: 6 Layers Backwards, Agentic Loops

One warning on module two, because it's where self-learners lose the most time. DSPy's docs are good but they're organized as a tour, not a course; the thing the Oct 7 lecture will give enrolled students is the comparison: signatures/modules/optimizers against LangGraph's graph-of-nodes against LlamaIndex's data-first view. Without that framing you tend to learn one framework's vocabulary and mistake it for the concept. The fix is the exercise in the table: port the same harness across two frameworks and write the diff in prose. The prose is the deliverable.

For a broader map of what's free this fall, including CMU's parallel agents course, see the Fall 2026 free AI agent courses hub and the CMU 11-768 breakdown.

The Most Valuable Week for Readers of This Blog

If you already run coding agents in production, the obvious pick is November 18: coding agents, taught by the person who wrote SWE-agent, covering Claude Code and OpenHands architectures side by side. It'll be the most fun lecture of the quarter. It's not the most valuable one for you, because you've already read the SWE-agent paper, the Claude Code best-practices post, and probably this blog's harness series, and there's no recording anyway.

The most valuable block is the evaluation fortnight, November 4 and 9, plus the HW2 brief. Here's my reasoning. In the 60 days I tracked a harness in production for the six-layers post, the layers that drove stability were eval and recovery, not the loop, and eval was the layer I built last and worst. That's the common pattern: teams build the loop in a week, tune prompts for a month, and then ship without a benchmark they'd bet money on. CS329Z spends three lectures and a full homework on exactly this, and the 4-tuple framework (request, environment, stopping criteria, scorer) is a portable artifact you can apply to any agent tomorrow, no Stanford login required.

Second place goes to October 21 (optimization), for a narrower audience. If your team is fine-tuning because "prompting plateaued," the GEPA paper on that week's list reports beating GRPO with up to 35x fewer rollouts through reflective prompt evolution. Whether that holds on your task is an afternoon with dspy.GEPA and your dev set, and that afternoon might cancel a fine-tuning project.

What You Can't Get Without Enrolling

Self-study gets you the readings, the topic list, and two reconstructable homeworks. It doesn't get you these, and I'd rather list them than pretend the substitute is equivalent.

The recordings. Cameras capture the instructor; the footage goes to Canvas. Non-enrolled means no video, full stop. Stanford Online does list CS329Z as a course, which for other CS courses means non-degree enrollment at the published rate of $1,575 per unit with a 3-unit minimum (roughly $4,725 plus a $250 document fee). The listing itself wouldn't load for me, so confirm the non-degree option before you budget for it.
The homework infrastructure. The email archive, the pre-built agent for HW2, the autograders, and whatever starter harness they hand out. My substitutes above are reconstructions from the brief, not the real assignments.
The quizzes. Fifteen percent of the grade is a closed-book, ten-minute defense of your own design decisions. That's the single best forcing function in the course and it doesn't exist outside it, unless you get a colleague to grill you.
The two guest lectures (Oct 26 and Nov 16, speakers TBA). CS146S's guest list was a major draw; CS329Z hasn't announced anyone yet.
Feedback from Michael Ryan and John Yang on your eval suite and your optimizer runs. This is the thing I'd pay for.
Demo day and a team. "Making Life at Stanford Better with Agents" is a group project with a proposal, a midway report, and a demo in finals week. Alone, you can build the system; you can't fake the deadlines or the audience.
Credit. Three units, letter or credit/no credit, repeatable: no.

Verdict

CS329Z is the first Stanford course that treats agents as an engineering discipline rather than a developer skill, and it proves it by grading design decisions and evals rather than lecture recall. Follow it if you build agents for other people to use; follow CS146S if you use agents to build for other people; skip both if you haven't yet written a tool-calling loop against a raw API, because both courses assume you have.

Without the recordings, the useful part of CS329Z is about 70% available: 50 public readings and two homework briefs specific enough to rebuild. Do HW1 with zero frameworks and HW2 against an agent you didn't write, and you'll have covered the part of this course that the industry most needs and least teaches. I'll update this page when the slides land or the guests are announced.

gitui vs lazygit in 2026: Benchmarked on 82K Commits

Bruce He — Fri, 11 Sep 2026 07:45:22 +0000

Eleven milliseconds. That's how long gitui took to paint a usable screen on an 82,180-commit clone of git/git on my M5 MacBook, and the number didn't move when I pointed it at a 630-commit blog repo instead. Lazygit took 416 ms on the same repo. If you came here for "gitui vs lazygit, which is faster," you can stop reading: gitui, by a factor of nearly 40.

It's also the least important fact in this comparison. The tool that paints 40x faster can't do an interactive rebase, can't show you a conflict diff, has no custom commands and no worktree view, and shipped three releases in the last twenty months. The tool that takes 416 ms shipped twelve in the last seven.

So the real question isn't speed. It's whether the things gitui does uniquely well (blame, full-tree browsing, flat memory on giant histories) matter more to you than the things only lazygit does. I spent a week with both, wrote a pty harness to time them properly, and I'll give you the receipts and then a straight answer.

The gitui vs lazygit benchmark: three repos, one harness

Cards on the table: you can't benchmark a TUI with hyperfine the way you'd time ls. Both tools refuse to start without a terminal, and "startup time" is meaningless until the screen shows something you can act on. So I wrote a small Python harness that forks each tool inside a pseudo-terminal, feeds the output into a pyte screen emulator, and stops the clock when the screen meets a readiness condition. For lazygit that's "the Commits panel is drawn and contains a hash." For gitui it's "the tab bar is drawn and every Loading ... placeholder is gone." Memory is the RSS of the whole process tree sampled after the screen settles, because lazygit spawns git children (it auto-fetches on launch) and those count.

Setup, so you can reproduce or argue with it:

Item	Value
Machine	MacBook Pro, Apple M5, macOS 26.5.2
lazygit	v0.65.0 (Homebrew, released 2026-09-05), 18.4 MB binary
gitui	v0.28.1 (Homebrew, released 2026-03-24), 9.5 MB binary
Small repo	this blog, 630 commits
Medium repo	neovim/neovim, 38,077 commits, 331 MB `.git`
Large repo	git/git, 82,180 commits, 334 MB `.git`
Cache	warm (10 runs each, median reported); I couldn't purge the page cache without sudo, so no cold numbers
Terminal	200x50 pty, `TERM=xterm-256color`, startup popups disabled

Time to a usable screen (median of 10 runs):

Repo	lazygit	gitui	Ratio
630 commits	88 ms	11 ms	8x
38,077 commits	232 ms	11 ms	21x
82,180 commits	416 ms	11 ms	38x

Memory (process tree RSS) right after that screen:

Repo	lazygit	gitui
630 commits	43 MB	16 MB
38,077 commits	34 MB	18 MB
82,180 commits	40 MB	31 MB

Those numbers describe two different strategies, not two speeds of the same strategy. Gitui draws the frame first and fills it asynchronously: at 11 ms the status tab is ready, and the log tab is still counting up in a corner (300/3000, then 82180/82180). Lazygit runs git log for the first 300 commits, builds the graph, and only then shows you anything. That's why its startup scales with history and gitui's doesn't.

What 11 milliseconds actually buys you

The honest framing: gitui's speed advantage is real, and below roughly 100K commits you will not feel it. A 416 ms launch is slower than a keypress but faster than a tab switch in VS Code. Where the strategies diverge for real is when you want the whole history, and that's where the numbers get dramatic.

Full history loaded	lazygit	gitui
38,077 commits: time	under 0.5 s (press `>` twice in Commits)	150 ms from launch
38,077 commits: RSS	129 MB	25 MB
82,180 commits: time	1.92 s	484 ms from launch
82,180 commits: RSS	716 MB (peak 788 MB)	31 MB
Jump to the first commit ever	after the load above	instant, 24 MB

(interactive diagram — view it on the original post)

Lazygit at 716 MB isn't a leak, it's the commit graph. Lazygit renders the branch-line graph for every loaded commit, and on git/git's merge-heavy history that graph is dozens of columns wide. Gitui doesn't draw a graph at all (branch visualization is roadmap item #81), so it keeps a flat list and a flat memory profile. You are trading a picture of the history for 23x less RAM. On a laptop with 16 GB that's a trade you never notice; on a shared dev box with a 2M-commit monorepo it's the difference between a tool you use and a tool you kill.

This also puts gitui's own README benchmark in perspective. It quotes the Linux kernel (900K+ commits): 24 s and 0.17 GB for gitui versus 57 s and 2.6 GB for lazygit, with lazygit "freezing" and "sometimes crashing." Those numbers date to a 2020 RustBerlin meetup talk and were measured on lazygit builds several years old; I saw no freezes or crashes at 82K commits on v0.65.0. Extrapolate my memory curve, though, and 2.6 GB at 900K commits is entirely plausible. The README isn't wrong, it's just describing a repo size most of us don't work in.

Verdict on performance, dated 2026-09-02: if your repo has fewer than ~100K commits, startup speed should not be in your decision at all. If you routinely read the entire history of a Linux-kernel-sized repo, gitui is the only one of the two that does it comfortably.

Feature matrix from a week of real use

Everything below I did with my own hands on v0.65.0 and v0.28.1, not from the READMEs. Where a feature is missing I link the issue so you can watch it.

Capability	lazygit v0.65.0	gitui v0.28.1
Interactive rebase (squash, fixup, reorder, drop, edit)	Yes, in-place in the commits panel	No; #32 open since 2020-04-23, 91 reactions
Line and hunk staging	`space` / `v` range select	`s` stage lines, Enter stage hunk; equally good
Conflict resolution	Dedicated view: pick hunk, pick both, next conflict, undo	Marks file `!`, diff panel shows `size: 0 B -> 62 B` and nothing else (#2865); resolve in an external editor
Custom commands	YAML `customCommands` with Go templates, prompts and menus	None
Worktrees	Files panel has a Worktrees tab; `w` creates one from a branch	No worktree view
Blame	None (not in the keybindings reference)	`B` in the Files tab, syntax highlighted, go-to-line
Browse the full tree at any commit	No (only changed files)	Files tab, any revision
Commit graph	Yes	No
Amend an old commit / custom patches / bisect / undo	Yes; `ctrl+z` undoes almost anything via the reflog	Amend HEAD only; no bisect; `U` undoes the last commit and that's it
Keybinding discovery	Context bar at bottom plus `?` filterable menu	Context bar at bottom plus `h` help popup
Config format	YAML (`config.yml`)	RON (`theme.ron`, `key_bindings.ron`)
Nerd Font	Optional icons (`gui.nerdFontsVersion: "3"`)	Not used
UI languages	auto-detects zh-CN, zh-TW, ja, ko, ru, pl, nl, pt	English only
Windows install	winget, scoop, choco	winget, scoop, choco
Releases, last 12 months	17 (v0.55.1 on 2025-09-17 through v0.65.0 on 2026-09-05)	2 (v0.28.0 on 2025-12-14, v0.28.1 on 2026-03-24)
GitHub stars (2026-09-02)	82,214	22,477

Three rows on that table decided the article for me.

Interactive rebase. I wrote a whole post about why lazygit's rebase feels like cheating, and nothing in gitui replaces it. Gitui's log tab offers reword, revert, reset and "rebase branch" (a plain git rebase onto another branch). It does not let you squash two commits, move one above another, or drop one. The 91 thumbs-up on issue #32 say I'm not alone in wanting that, and the fact that it's been open for six years says it isn't coming soon. If you rebase weekly, this row alone ends the comparison.

Conflicts. I built a two-branch repo with a one-line conflict and opened both tools. Lazygit switched the files panel to "(only conflicting)", showed the <<<<<<< / ======= / >>>>>>> blocks in the right pane, and the bottom bar read Pick hunk: <space> | Pick both hunks: b | Previous conflict: <left> | Next conflict: <right> | Undo: z. Gitui marked app.py with a !, and the diff pane said size: 0 B -> 62 B (+62 B) on an otherwise empty panel. The only conflict-specific key was Abort merge. That's an open bug (#2865), and the workaround is e to open your editor, which is exactly the trip a TUI is supposed to save you.

Blame and tree browsing. This is where gitui genuinely wins, and I don't want the rebase point to bury it. Lazygit's Files panel only lists changed files; there is no way to walk the repository tree and ask "who wrote this line." Gitui's Files tab shows the whole tree at any commit, B gives you a syntax-highlighted blame with go-to-line, and H gives per-file history. When I'm reading an unfamiliar codebase, that's the thing I actually want from a Git TUI, and lazygit simply doesn't have it.

gitui vs lazygit for AI coding agents

The way I use Git changed in 2025: most diffs on my machine are now written by Claude Code or Codex, and my job is to review them, not author them. That shifts what I need from a Git TUI, and it shifts the comparison hard toward lazygit for three concrete reasons.

Hunk-by-hunk review of agent output. Both tools stage lines. But an agent-generated diff is where you want to stage the good half of a file, drop the hallucinated half, and commit in logical units the agent didn't think about. Lazygit's v range select plus its "custom patch" flow (pull lines out of a commit the agent already made) covers that; gitui stops at staging.

One worktree per agent. Running two or three agents in parallel means one worktree per task, and the annoying part is never creating them, it's remembering which is which and cleaning up. Lazygit's Worktrees tab lists them, switches with space, and deletes directory plus metadata with d. Gitui has no worktree concept; the only mentions in its tracker are bugs about running inside one.

Custom commands as the glue. This is the feature that makes lazygit a hub rather than a viewer. Two bindings I actually use, in config.yml:

customCommands:
  # Copy the selected commit's diff so I can paste it to the agent for a review pass
  - key: '<c-y>'
    context: 'commits'
    command: 'git show {{.SelectedCommit.Hash}} | pbcopy'
    description: 'Copy commit diff to clipboard'
  # Open a Claude Code session in the selected worktree, in a new tmux window
  - key: 'C'
    context: 'worktrees'
    command: 'tmux new-window -c {{.SelectedWorktree.Path | quote}} "claude"'
    description: 'Start Claude Code in this worktree'

Gitui can't express either of those. There is no custom command system, and searching its issues for one turns up nothing beyond a closed build error. For a pure "look at the repo" tool that's fine; for a tool that sits between me and an agent, it's disqualifying.

The one place gitui earns a slot in an agent workflow is review of unfamiliar code the agent touched: B blame on a file to see whether the line it changed was load-bearing and who last touched it. I keep gitui installed for exactly that and open it maybe twice a week.

Two things I hit that neither README mentions

Lazygit shows escaped bytes in diff headers for non-ASCII paths. I made a repo with a file named 中文文件名.md. Lazygit's file tree rendered the name correctly, but the diff header read diff --git "a/\344\270\255\346\226\207...", because lazygit shells out to git diff and Git quotes non-ASCII paths by default. One config line fixes it globally, and you should set it anyway if you ever touch CJK, accented or emoji file names:

git config --global core.quotepath false

Gitui was clean out of the box because it reads diffs through libgit2 instead of parsing porcelain output. Small thing, but it's the kind of small thing that makes a tool feel broken on day one.

Lazygit picks your UI language from the locale. On my machine, which runs a zh_CN locale, lazygit v0.65.0 launched with a fully translated Chinese interface before I'd touched a config file (gui.language: auto is the default). Nice for the audience of this blog's Chinese edition, mildly startling if you're following an English tutorial and every keybinding hint is in another language. Set gui.language: en if you want the docs to match your screen. Gitui has no localization at all.

Neither hurt gitui, so in fairness, the gitui-specific wart I found is older and documented: over HTTPS it needs credential.helper set explicitly or push and fetch fail, and on WSL2 there's a still-open report of fetch and pull hanging while the CLI and lazygit work. I couldn't test Windows or WSL in this session; treat those as things to check on your own box, not as findings.

Verdict: install lazygit, keep gitui for blame

(interactive diagram — view it on the original post)

My recommendation, as of September 2026, for most people reading this:

brew install lazygit (or winget install -e --id=JesseDuffield.lazygit, scoop install lazygit) and make it your daily driver. It's the one with rebase, a real conflict view, worktrees, custom commands, seventeen releases in twelve months and 82K stars. The 416 ms it costs to open on an 82K-commit repo is a price you'll stop noticing by Tuesday.
Also install gitui if you read other people's code for a living, work in a repo with hundreds of thousands of commits, or just want B for blame. It's a 9.5 MB binary, 16 MB of RAM, and it has no opinions about your workflow. Bind it to a separate alias and let it be the microscope while lazygit is the workbench.
Pick gitui alone only if history rewriting is something you never do and memory on the box is genuinely tight. That's a real population (SRE boxes, Termux on a phone, a 2M-commit monorepo on a shared VM), it's just not most developers.

What I'd skip: choosing by language. "gitui is Rust, lazygit is Go" tells you the binary size (9.5 vs 18.4 MB) and nothing about which one will get you out of a botched merge at 6 pm. Choose by the feature rows above.

If you're coming from the fish shell and Rust-tool crowd and want the rest of the terminal sorted first, my terminal emulator roundup and the Windows Terminal ranking cover the layer underneath either of these.

Footnote on tig: yes, it still exists (13.3K stars, v2.6.1 in June 2026), and as a read-only pager over git log it starts even lighter than gitui. It doesn't stage, rebase or resolve anything, so it isn't a third contender here; it's a very good less for Git.

Codex App Guide (2026): Setup, Workflows, and Real Pitfalls

Bruce He — Fri, 10 Jul 2026 10:34:48 +0000

The Codex app is OpenAI's desktop command center for coding agents — and since July 9, 2026, it's no longer a standalone download but a dedicated Codex mode inside the new ChatGPT desktop app, sitting next to Chat and Work. It runs the same agent as the open-source Codex CLI, bills against your existing ChatGPT plan (every tier, including Free), and its specialty is running several agents in parallel, each in its own git worktree, while you review diffs instead of babysitting a terminal. If you already pay for ChatGPT, installing it costs you nothing but disk space, and it's the easiest on-ramp to agentic coding that exists right now.

That's the three-sentence answer. The rest of this guide is the long version: what the app actually is after the merger, how to set it up properly, the workflows that make it worth the screen real estate, what every plan really gets you, where it loses to the CLI and to Claude Code, and the pitfalls that are currently filling up Hacker News threads.

One thing before we start, so this page stays honest: I've lived in Codex CLI since February, but I have not run months of production work through the desktop app. Everything here is built from OpenAI's own docs and changelog, the launch and merger announcements, and a lot of community receipts — and where something is contested, I say so.

Version anchor: this guide describes the state of the Codex app as of July 12, 2026 — three days after the ChatGPT desktop merger. Given that this product changed shape three times in six months, check the official changelog if you're reading this from the future. I'll keep this page updated as the app evolves.

What Is the Codex App in July 2026?

Start with the fact that confuses everyone this week: the Codex app didn't die on July 9 — it got promoted. OpenAI merged the standalone app into a rebuilt ChatGPT desktop app for macOS and Windows, where Codex is now one of three modes (Chat, Work, Codex). Your projects, threads, and settings carried over; existing Codex app installs simply updated into the new shell. The old ChatGPT desktop app was renamed "ChatGPT Classic" — more on why that name is a problem later.

As of July 2026, the Codex app lives as a dedicated mode inside the ChatGPT desktop app (macOS Apple Silicon and Windows), is included in every ChatGPT plan including Free, and serves over 5 million weekly users — up from roughly 600,000 in January 2026, per OpenAI's own June 2 figures.

That growth curve is the reason this product deserves a pillar guide. OpenAI's numbers: 600K weekly users at the start of 2026, over 2 million by March, 4 million by April 21, past 5 million by June 2. Even more telling: about 20% of those users aren't developers, and the non-developer segment is growing three times faster. Andrew Ambrosino, who leads the Codex desktop team, said in a July 5 interview that marketing, finance, and legal teams kept adopting a tool built for engineers — which is exactly why OpenAI stopped shipping it as a developer-only product. The merger wasn't a demotion; it was OpenAI concluding that "the boundary between developer tools and general-purpose knowledge tools is collapsing."

It helps to see where the app sits in the Codex product family, because "Codex" is one agent wearing four different outfits:

(interactive diagram — view it on the original post)

The practical takeaway: nothing you learn in the app is wasted in the CLI, and vice versa. Both surfaces read the same AGENTS.md, share user-level configuration under ~/.codex, and pull from the same plan limits. The app is not a different product with a different brain — it's a control room bolted onto the same engine, and that's precisely how you should use it.

From Launch to Merger: Six Months of Whiplash

The Codex app's first half-year explains most of its current quirks, so here's the timeline in one table, straight from OpenAI's changelog and launch posts:

Date (2026)	What happened
Feb 2	Codex app launches on macOS (v26.202): parallel agent threads, project sidebar, built-in review
Mar 4	Windows version ships (v26.304), with a native Windows sandbox and PowerShell support
Apr 2	Pricing switches from per-message to API-token-aligned credits
Apr 16	"Codex for almost everything" update: computer use, in-app browser built on Atlas, image generation
May 21	v26.519: Goal mode goes GA, remote computer use, plugin marketplace sharing
Jul 9	Codex app merges into the new ChatGPT desktop app as a dedicated mode; old ChatGPT app renamed "Classic"

Read that sequence back and the product strategy is legible: launch as a developer tool, discover non-developers love it, add computer use and a browser so it can touch everything, then fold it into the consumer flagship. I covered the strategic fork this creates — OpenAI betting on the super-app while Anthropic bets on composable CLI primitives — in my GPT-5.6 release analysis, and I won't re-litigate it here. What matters for this guide is the practical consequence: the Codex app's roadmap now answers to a consumer product, and developers evaluating it should price in some consumer-first decisions over the next few quarters.

Installing and Setting Up the Codex App

Requirements first, because they exclude people. The ChatGPT desktop app runs on macOS with Apple Silicon (M1 or later — Intel Macs are out) and on Windows. There is no Linux build, and OpenAI has announced no plans for one. If you're on Linux, stop here and use the Codex CLI — same agent, same plan limits, no GUI.

Setup is genuinely a five-minute affair:

Download the ChatGPT desktop app from chatgpt.com (existing Codex app installs auto-update into it).
Sign in with your ChatGPT account — no API key needed. This is the single biggest onboarding difference from most agent tools: billing rides your existing subscription.
Switch to Codex mode and point it at a project folder. Codex treats each folder as a project, with threads organized underneath.
Pick your permission posture when prompted. Like the CLI, the app runs agents in a sandbox with bounded file and network access, and asks before escalating.
Check your AGENTS.md. If your repo already has one for the CLI, the app reads the same file. If not, write one — repo conventions, build commands, test commands — before you run anything serious.

Two configuration details worth knowing on day one. First, user-level settings live in ~/.codex/config.toml and are shared across the app, CLI, and IDE extension — MCP servers you configured for the CLI show up in the app for trusted projects. Second, the app distinguishes local environments (agents work directly on your machine, in worktrees) from cloud environments (tasks run on OpenAI's infrastructure, like Codex web). Cloud tasks are how you fire off work from your phone and review it later, but note that they draw from the same usage window as local messages — a pitfall we'll get to.

Core Codex App Workflows: Threads, Worktrees, Parallel Agents

Here's the mental model that makes the app click: every thread is a workspace, not a chat. When you start a new thread in a project, Codex quietly creates a git worktree for it — an independent checkout that shares the same .git metadata as your main repository. The agent works there, isolated from your working directory and from every other thread. You can have three agents refactoring, bug-fixing, and writing tests simultaneously without any of them stepping on your uncommitted changes.

(interactive diagram — view it on the original post)

This is, frankly, the app's killer feature — and it's worth naming why. Anyone who has tried to run parallel agents from the terminal knows the tax: manual git worktree add, one terminal tab per agent, and a cleanup ritual when you're done. The CLI still makes you do all of that yourself (community guides exist precisely because the CLI lacks built-in worktree automation). The app does it silently, per thread, with cleanup handled when threads close. If parallel agent work is your goal, the app isn't a dumbed-down CLI — on this one axis it's ahead.

The workflow that follows from this: stop watching agents work. The intended loop is queue several threads, go do something that needs your brain, come back and review. The July 9 release sharpened the review half considerably — you can now edit diffs inline inside the app instead of round-tripping through your editor, and a PR review side panel brings the review-before-merge step into the same window. Reviewing three agents' diffs in sequence turns out to be a much better use of attention than watching one agent think in real time.

Beyond the core loop, three features distinguish the app from every other Codex surface:

Computer use. Since April, Codex agents can see your screen and operate any app with their own cursor — and since July 9, this runs on GPT-5.6 and is noticeably faster. Multiple agents can do this in parallel without hijacking your actual mouse. It's the feature with the highest wow-factor and the highest risk surface; scope it to the apps a task actually needs.

The in-app browser. Built on OpenAI's Atlas engine, it lets an agent iterate on frontend work — run the dev server, look at the page, fix the CSS, look again — without you alt-tabbing to verify. For frontend iteration loops, this quietly removes the most annoying human-in-the-loop step.

Automations and Goal mode. Scheduled tasks ("run the test suite triage every morning") and goal-directed longer runs went GA in May. This overlaps with what ChatGPT Work does for non-code tasks, and the boundary between them is genuinely blurry — a confusion OpenAI has earned, as the pitfalls section will show.

Codex App Pricing: What Every Plan Actually Gets

The headline is friendlier than you'd expect: Codex is included in every ChatGPT plan, and since April 2, 2026, usage is metered in credits that map directly onto API token prices. Here's the plan lineup as of July 2026, per OpenAI's pricing docs:

Plan	Price	Codex allowance (local messages / 5-hour window)
Free	$0	Limited taste
Go	$8/mo	Light usage
Plus	$20/mo	~20–110, depending on model
Pro	$100/mo	5x Plus (~100–550)
Pro 20x	$200/mo	20x Plus (~400–2,200)
Business	$25/user/mo	Plus-tier limits per seat
Enterprise/Edu	Custom	Credit-based, scales with contract

The credit rates are where you should actually look, because they tell you which model to run. Per million tokens: GPT-5.6 Sol costs 125 credits in / 750 out, Terra 62.5 / 375, and Luna 25 / 150. Run the arithmetic against OpenAI's API prices ($5/$30, $2.50/$15, $1/$6) and every tier lands on the same exchange rate: one credit ≈ 4 cents of API value. That's a deliberately clean design — your subscription is effectively a prepaid API balance with a generous multiplier, and when you exhaust a 5-hour window, you can buy top-up credits instead of upgrading a tier.

The practical advice falls out of the table. Luna costs one-fifth of Sol per token, and for routine agent work — test fixes, small refactors, scripted chores — the quality gap rarely justifies a 5x burn rate. My suggested default: Terra for daily driving, Luna for bulk chores, Sol reserved for the tasks you'd have escalated to a senior engineer. This mirrors the tiered-model advice from my GPT-5.6 pricing breakdown, where the benchmark gaps between tiers turned out smaller than the price gaps.

Two cost gotchas the pricing page won't shout about. Cloud tasks share the same 5-hour window as local messages — delegating to the cloud doesn't buy you extra capacity, just extra parallelism. And image generation burns your included limits "3–5x faster on average," per OpenAI's own docs, so a design-heavy session can eat a window surprisingly fast.

Codex App vs Codex CLI vs Claude Code

This is the decision most readers came for, so let's do it properly. The app-versus-CLI question is easy because they're the same agent; the Codex-versus-Claude-Code question is a real fork, and I compared the underlying agents in depth in Claude Code vs Codex — here I'll focus on what the desktop app changes.

	Codex app	Codex CLI	Claude Code
Form	GUI mode in ChatGPT desktop	Open-source terminal agent	Terminal agent + SDK
Platforms	macOS (Apple Silicon), Windows	macOS, Linux, Windows	macOS, Linux, Windows
Parallel agents	Built-in, automatic worktrees	Manual worktree setup	Manual worktrees / subagents
Review	Inline diff edits, PR panel	Terminal diffs	Terminal diffs
Computer use	Yes, parallel, GPT-5.6	No	No (browser via MCP)
Scripting / CI	No	Yes — `codex exec`, least-privilege sandbox	Yes — SDK, hooks, headless mode
Billing	Any ChatGPT plan, incl. Free	Same plans, or API key	Claude Pro/Max, or API
Extensibility	Plugins, MCP, marketplace	MCP, AGENTS.md, open source	Skills, MCP, hooks, plugins

My read, stated plainly:

Choose the Codex app if you already pay for any ChatGPT plan and you want parallel agents with a real review surface — or you're the kind of user who was never going to open a terminal. The marginal cost is zero, the worktree automation is genuinely best-in-class, and for reviewing multiple agents' output it beats every terminal workflow I know.

Stay on the CLI if your agent work feeds scripts, CI pipelines, or cron jobs. codex exec runs read-only by default and escalates permissions explicitly — exactly the posture you want for automation, and something the app simply doesn't do. The app also can't be driven programmatically. They share config, so "both" is a legitimate answer: CLI as the backbone, app as mission control.

Claude Code holds its ground if your workflow is already built on it. Nothing in the July 9 release creates a capability gap that justifies a migration — Claude Code's Skills/hooks/SDK ecosystem remains the deeper toolbox for engineers who script their agents, an argument I made at length in CLI + Skills vs MCP. The honest asymmetry: OpenAI now offers the better no-terminal agent experience, Anthropic the better terminal-native one. Pick the side that matches where you live, and note that Anthropic's answer to the app — Claude Cowork, its desktop working-session product — is aimed at office workers, not at developers running parallel worktrees.

Six Pitfalls That Bite New Codex App Users

Every one of these comes with a receipt — most from the Hacker News thread on the merger, which is the most useful unfiltered field report available right now.

1. Work mode and Codex mode look identical, and sometimes are. The top complaint post-merger: toggling between Work and Codex produces no visible change for many tasks, and OpenAI hasn't clearly documented what differs. Practical rule until they fix the UX: repo work in Codex mode (you get worktrees and diff review), documents and spreadsheets in Work mode, and don't expect the toggle to change the model's brain.

2. The merged app dropped ChatGPT features you may rely on. Early merged builds are missing temporary chats, voice mode, Deep Research, and custom GPTs, and chat history is squeezed into a small popup. If those matter to you, keep "ChatGPT Classic" installed alongside — and yes, multiple HN commenters pointed out that naming an app "Classic" reads like a deprecation notice. Treat it as one.

3. Codex writes to your filesystem in places you didn't ask for. Users report the app auto-creating folders in ~/Documents. Combine that with per-thread worktrees and you can accumulate surprising disk clutter; close finished threads so cleanup runs instead of leaving a dozen live worktrees behind.

4. Cloud tasks and images drain the same meter as local work. Both share your 5-hour window, and image generation burns it 3–5x faster. If you hit caps mysteriously early, check whether background cloud tasks or image calls are the culprit before blaming the model picker — and remember Sol burns five Lunas per token.

5. Computer use is powerful and deserves paranoia. An agent that can see your screen and click anything is a lateral-movement risk if a task ingests malicious content — security researchers flagged exactly this boundary question when the feature shipped in April. Grant it specific apps per task, never blanket access, and keep it away from password managers and banking tabs.

6. IT management broke with the bundle ID change. On macOS the app now ships as com.openai.codex instead of com.openai.chatgpt, which silently breaks MDM policies, allowlists, and automation scripts pinned to the old identifier. If you manage a fleet, update your policies before your users update their apps.

The Bottom Line

The Codex app in July 2026 is an easy recommendation with a narrow shape: if you pay for ChatGPT at all, install it, point it at a real repo, and run two parallel threads through the review panel — that experience, not benchmarks, will tell you whether it fits your work. It's the best zero-marginal-cost entry into agentic coding on the market, and its worktree-per-thread design is something even terminal loyalists should steal.

But keep the roles straight. The app is a control room; the CLI is the engine you can script. The merger that made Codex a tab in a consumer super-app is great for its distribution and unproven for its developer roadmap — the feature gaps and mode confusion of the July 9 build are exactly what shipping a consumer pivot in a hurry looks like. Use the app for what it's uniquely good at today, keep your automation on the CLI, and check back on this page: this product has changed shape three times in six months, and I doubt it's done.

Claw Code: The Open-Source Claude Code Rewrite That Hit 100K Stars

Bruce He — Fri, 10 Jul 2026 10:31:51 +0000

Originally published at heyuan110.com

On March 31, 2026, a missing .npmignore entry shipped 512,000 lines of unobfuscated TypeScript to the public npm registry — the entire internal architecture of Claude Code laid bare.

Two days later, Claw Code launched as a clean-room Python and Rust rewrite. It became the fastest-growing repository in GitHub history, surpassing 100,000 stars in its first hours.

This article examines:

What exactly leaked and how (the npm packaging error)
What Claw Code is — architecture, design decisions, key differences
Claude Code vs Claw Code architecture comparison
Legal and ethical analysis: is a clean-room rewrite actually safe?
Should you switch from Claude Code? (Honest assessment: probably not yet)

Read the full article →

If you found this useful, check out my blog for more AI engineering guides.

Claude Code vs Cursor vs Copilot 2026: The Definitive Three-Way Comparison

Bruce He — Fri, 10 Jul 2026 10:31:41 +0000

Originally published at heyuan110.com

The AI coding tool landscape in April 2026 has consolidated around three clear leaders: Claude Code, Cursor, and GitHub Copilot. After eight months of using all three daily on production codebases, here is the honest comparison.

Three fundamentally different philosophies:

Claude Code: Terminal-native agent — AI operates at system level
Cursor: IDE-native AI — fork of VS Code rebuilt around AI
GitHub Copilot: Universal plugin — meets devs where they already work

Key findings:

Claude Code wins at deep reasoning and large refactors (1M token context)
Cursor wins at speed for routine tasks (Composer 2 at $0.50/M tokens)
Copilot wins at reach and simplicity ($10/mo, works in any IDE)
Most productive developers use 2+ tools, not just one
The Kimi K2.5 controversy means Cursor's transparency is questionable

Read the full article →

If you found this useful, check out my blog for more AI engineering guides.

Claude Fable 5: When the $10/$50 Flagship Is Worth It

Bruce He — Fri, 10 Jul 2026 10:31:23 +0000

Three tasks. That's all it took to burn through 73% of a five-hour usage window — and one of the three never even finished. It happened to Kazike, a Chinese blogger on the $200/month Max 20x plan — the most expensive consumer tier Anthropic sells — during Fable 5's free window. He said it was the first time he'd ever felt token scarcity; in years of shipping code on Opus 4.8, it had never happened once.

Here's the part that should worry you: that was while Fable 5 was free.

On July 13, 2026, Claude Fable 5 drops out of every subscription plan. That same burn rate now pulls real dollars from a separately funded usage-credit balance: $10 per million input tokens, $50 per million output. No frontier lab has ever done this — ship your best model, let everyone get a taste, then stick a meter on it.

So this post is about money, start to finish: what a Fable 5 task actually costs, which tasks are worth it, and how to make sure the run you pay for doesn't go sideways. "What should my default model be" is a different question — I covered it in my cross-vendor comparison, and the answer is still Sonnet 5.

Cards on the table: Fable 5 is a per-task purchase, not a monthly teammate. At $30–100 a run, it only pencils out when one successful run plausibly replaces half a day of your own work.

Where Fable 5 Lives After July 13

Fable 5 didn't disappear — it went from subscription perk to metered add-on. Its status has whipsawed all month, so here's the whole saga, checked against Anthropic's own statements and squeezed into one table:

Date (2026)	What happened
June 9	GA; in-plan access announced as free through June 22
June 12	US government directive suspends access for all foreign nationals
June 30	Export controls lifted
July 1	Redeployed globally; Pro/Max/Team get it for up to 50% of weekly limits, through July 7
July 7	After subscriber backlash, extended five days to July 12, 11:59 PM PT
July 13 →	Usage credits only, at API rates, on top of any plan

Read that sequence back: free, banned overnight, restored, pulled again — four states in one month. And the July 7 extension didn't come from goodwill; subscribers forced it, and what they were angry about is the math in the next section.

As of July 13, 2026, Claude Fable 5 is not included in any Claude subscription plan. It bills through a separate usage-credit balance at $10 per million input tokens and $50 per million output tokens, and Anthropic has announced no date for restoring in-plan access.

Two claims making the rounds deserve corrections. First, Fable 5 is not "API-only" after the cutoff. It's still right there in the model picker in Claude.ai and Claude Code; it just bills your usage-credit balance instead of your plan's included limits. You can keep your $20 Pro plan and run Fable 5 tonight — you'll just be watching a dollar meter instead of a usage bar.

Second, "temporary" is doing a lot of work in Anthropic's framing. The company says it'll restore in-plan access once serving capacity allows — and as of July 12, there's no timeline attached. Budget as if this lasts months, not days.

Two hard constraints also carry over unchanged from June. Fable 5 has mandatory 30-day data retention and is excluded from zero-data-retention agreements — ZDR organizations get a 400 on every request, full stop. And its safety classifiers decline with stop_reason: "refusal" often enough to matter for anything security-adjacent. Its unclassified sibling Mythos 5 remains limited to Project Glasswing partners, so it isn't an option for the rest of us.

Fable 5 Pricing in Practice: How $10/$50 Becomes $30–100 a Task

The sticker price is the least useful number in this whole decision. Three multipliers sit between $10/$50 and what you actually spend — here's the math so you can plug in your own numbers.

Multiplier one: thinking you cannot turn off. On Fable 5, adaptive thinking is the only mode — thinking: {"type": "disabled"} isn't supported, and thinking tokens bill as output at $50 per million. Even a "short answer" carries reasoning overhead, hard turns can think for minutes, and your only throttle is the effort parameter, which most people never touch.

The thinking tax deserves its own line item. A 60-turn coding session averaging 5K thinking tokens per turn is 300K tokens of pure thought — $15 before a single line of code gets written. Opus 4.8 ($5/$25) lets you choose when to pay for extended thinking, so the effective output-price gap is much wider than the nominal 2x.

Multiplier two: agentic compounding. A Claude Code session isn't one API call; it's dozens of turns, each re-reading a growing context. Prompt caching absorbs most of it — cache reads cost about a tenth of fresh input — but the snowball still rolls: a two-hour session over a mid-sized repo routinely racks up tens of millions of cache-read tokens plus hundreds of thousands of output tokens.

Napkin math for a typical deep task: ~15M cache reads ($15) + 1M fresh input ($10) + 400K output including thinking ($20) — call it $45. That's the anatomy behind my working estimate of $30–100 per serious run. Plug your own usage into my Claude token cost calculator — a 20-turn session and an 80-turn session are the difference between a coffee and a dinner.

Multiplier three: retries you cause yourself. Every run that comes back wrong because you under-specified it is a full-price run. Nobody budgets for this one, and it's the one you control most directly — the last section of this post is entirely about shrinking it.

With all three multipliers in view, that opening 73% stops being mysterious: one deep Fable 5 task ate roughly a quarter of a Max 20x window, on Anthropic's priciest consumer tier. Carry that into post-July-13 billing and it gets scarier — three deep tasks a day at my per-task estimate works out to about a $3,000 month. The same tasks on Sonnet 5: fifty cents to two bucks each.

This isn't a price hike. It's a change of unit — from dollars per month to dollars per task.

Which is why "is Fable 5 worth it" has no answer in the aggregate — it only resolves task by task. (For how the subscription tiers map to real usage generally, see my Claude pricing complete guide.) The next section is the per-task answer.

The Half-Day Test: Which Tasks Deserve Fable 5

The rule I actually use has one clause: turn on Fable 5 only when a single successful run would plausibly replace at least half a day of your own skilled work. At $30–100 per run against $300+ of engineer time, that's a 3–10x return with margin for partial misses. Below the bar, you're paying a 5–20x premium for output you couldn't tell apart from a cheaper model's.

Three archetypes clear the bar consistently, each with concrete evidence.

The one-shot feature build. Back to Kazike. He wanted a time-decayed "trending" section for his AI news site — clustering, decay weighting, plus the edge case where a quiet news day should collapse the section entirely. He went through two design sessions with Opus 4.8 and walked away unhappy both times; Fable 5 took the same requirement and had it designed, built, and in production in 30 minutes, edge cases included.

That's the profile: a task with real design judgment in it, where the flagship's extra depth converts directly into not needing you in the loop.

The deep analysis report. This is the archetype that changed my mind about what the price buys. The same user asked Opus 4.8 to back-test a month of scoring data and got a report he described as insight-free; Fable 5 ran autonomously for 1 hour 18 minutes and produced an analysis that took him 20 minutes to read — flagging problems in his scoring system he had never thought to ask about. Hold onto "never thought to ask"; the last section collects on it.

The massive mechanical migration. This is the category Anthropic's own launch material staked out: Stripe ran a full-library migration across a 50-million-line Ruby codebase in a single day — work a team would have scheduled in months. Few of us have Stripe's problem, but the shape generalizes: enormous, latency-tolerant, machine-checkable, where a per-run fee is noise against the alternative.

The bar cuts just as hard the other way. Interactive edit-run-fix loops fail twice over: the task value is small, and the always-on thinking latency wrecks the rhythm — while iterating, a model that answers in 15 seconds at 90% beats one that answers in four minutes at 97%. High-volume pipeline work (test generation, lint sweeps, commit messages) fails on value. Security work fails on refusals: Kazike reported Fable 5 declining to audit his own codebase for vulnerabilities. ZDR organizations fail with a hard 400.

None of those are edge cases. Together they cover most of a normal working week — which is the honest core of any Fable 5 review: it is simultaneously the strongest model available and the wrong choice for most hours of the day.

Here's the whole ledger in one flowchart — if you screenshot one thing from this post, make it this:

(interactive diagram — view it on the original post)

The most important node is the one that loops: if your unknowns aren't clarified, the tree won't let you spend — it sends you back to a cheap model first. Note also what this tree is not: it doesn't pick your vendor or your default; that's the cross-vendor comparison. This one runs per task, after your default is set.

Quick reference by task type:

Task type	Model	Why	Cost per run (my estimate)
One-shot feature / frontend build	Fable 5	#1 WebDev Arena; one run ships the feature	$30–60
Deep analysis report over data or code	Fable 5	surfaces problems you didn't know to ask about	$50–100
Massive mechanical migration	Fable 5	Stripe-scale work, machine-checkable	scale-dependent
Daily agentic coding	Sonnet 5	beats Opus 4.8 on Terminal-Bench at 40% of the price	$0.5–2
Deep multi-file refactor	Opus 4.8	strong reasoning, no per-use meter	$5–15
Interactive edit-run-fix loop	Sonnet 5	Fable's thinking latency kills tight loops	cents
High-volume pipelines	Haiku 4.5	capability delta ≈ 0, cost delta ~10x	cents
Security / pentest tooling	Opus 4.8	Fable's classifiers refuse benign security work	—
Brainstorming / clarifying unknowns	Sonnet 5	the prep loop for a Fable run	cents

Close Your Unknowns Before You Pay

Deciding when to turn Fable 5 on is half the job; the other half is making sure the paid run is the one that works. The best guidance here comes from inside Anthropic: Thariq Shihipar, an engineer on the Claude Code team, published A Field Guide to Fable: Finding Your Unknowns on July 3, and it passed two million views within days on the strength of one sentence: "Fable is the first model where I find the quality of the work is bottlenecked by my ability to clarify its unknowns."

His frame is simple. Your prompt and context are a map; the codebase and its real constraints are the territory; the gap between them is the unknowns — and when Claude hits an unknown, it decides based on its best guess of what you want. For years the bottleneck was model capability: you pushed the model, and the model was what fell short. Fable 5 flips that. When a run comes back wrong now, the cause is usually a hole in your map.

My one addition is a cost footnote: at $50 per million output tokens, every unknown the model has to guess at is a line item on your bill. Thariq's own summary is accidentally a billing strategy: "Every explainer, brainstorm, interview, prototype, and reference is a cheap way to find out what you didn't know before it gets expensive to fix."

He sorts unknowns into four quadrants, each with its own move:

(interactive diagram — view it on the original post)

If you can state it, state it. Known knowns are ordinary spec-writing; no technique required.

If you know you haven't decided, get interviewed. One prompt does it: "Interview me one question at a time about anything ambiguous. Prioritize questions whose answers would change the architecture." That last clause does the real work — without it, the model asks trivia.

If you'd only recognize it on sight, go fishing. Unknown knowns are the standards you hold but would never think to write down. Ask for four throwaway design directions in one HTML page with fake data; your reaction to what's wrong is the missing spec.

If you can't even name the question, ask for a blindspot pass. Say it straight: "I'm adding an auth provider but I've never touched this codebase's auth module. Do a blindspot pass: what are my unknown unknowns here?" Telling the model what you don't know is the method, not an embarrassment.

Now to collect on that phrase from the half-day test. The analysis-report archetype is worth $100 precisely because it is a paid, industrial-strength unknown-unknowns pass — run over your data instead of your prompt. The framework and the cost math aren't two separate pieces of advice; they're the same economics viewed from the prompt side.

My Pre-Flight Checklist

The quadrants become a routine once you pin them to a sequence, and my biggest concrete recommendation is one Thariq's guide implies but never states: run the entire clarification phase on Sonnet 5, and let Fable 5 touch only the final execution run. Clarification is conversational, latency-sensitive, many-turn work — everything Fable 5 is bad at and Sonnet 5 is nearly free at. The cheap model asks the questions; the expensive model does the work.

Before (Sonnet 5, ~$1 of tokens):

Blindspot pass over any unfamiliar territory
Interview, one question at a time, architecture-changing questions first
Throwaway prototype with fake data for anything visual or UX-shaped
Reference pointers: "this Rust crate in vendor/rate-limiter has the backoff semantics I want; reimplement them in our TypeScript client" beats three paragraphs of prose
An implementation plan with the most volatile decisions at the top — data model changes, type interfaces, anything user-facing — because those are what you'll actually want to veto

The artifacts that prep loop produces — spec, prototype, references, plan — are exactly the curated context the expensive run consumes. That's context engineering in its purest form.

During (Fable 5, the metered part):

Start a fresh session and feed it the artifacts, not the conversation that produced them
Run one long session, not several short ones — warm cache and intact context beat re-clarifying every restart, and on a per-token meter, restarts are literally money
Have it keep an implementation-notes.md: on an edge case, take the conservative option, log the deviation, keep moving
Define "done" — and when the loop stops — before you launch; designing the loop before paying for it is the whole thesis of loop engineering, and it matters most when every lap has a price

After (either model):

Ask for a walkthrough report, then a quiz on the changes
Hold Thariq's line: merge only on a perfect score

A $50 run that ships code you don't understand isn't leverage; it's deferred debugging at flagship prices.

One last note from my own setup, because I didn't reason my way to these rules — I got burned into them. This blog's entire production pipeline runs on Claude Code — parallel agents drafting posts, generating covers, running validation — and parallelism is exactly where flagship pricing turns dangerous: a 5x per-token premium multiplied across N concurrent agents isn't an upgrade, it's a leak.

So my standing config is boring on purpose: cheap models by default, Fable 5 behind a manual, per-task escalation, released only for the single deep pass — the site-wide audit, the gnarly feature — where the half-day test genuinely clears. I paid real quota to learn that the thinking tax applies even to tasks that need no thinking. You don't have to pay it again.

What to Remember

As of July 13, 2026, Fable 5 is a metered add-on: $10/$50, usage credits, no restoration date. Treat it as a per-task purchase whose real price is $30–100 a run, turn it on only for tasks that pass the half-day test — one-shot builds, deep analysis, huge migrations — and let Sonnet 5 run everything else. Before every paid run, spend a dollar of cheap tokens closing your unknowns: with a model this strong, the bottleneck and the bill point at the same thing — your own clarity.

What SpaceX's $60B Cursor Acquisition Means for Developers

Bruce He — Fri, 10 Jul 2026 10:31:07 +0000

The company that catches falling rockets with steel chopsticks just paid $60 billion for a code editor. Not a satellite maker, not a defense prime — a VS Code fork. And it's real: on June 16, 2026, four days after the largest IPO in history, SpaceX announced it would acquire Anysphere, the company behind Cursor, for $60 billion in stock. CNBC confirmed the deal, Cursor CEO Michael Truell put his name on an official statement, and the transaction — the largest acquisition of a venture-backed startup ever — is expected to close in Q3 2026, pending regulatory approval. The SpaceX Cursor acquisition is not satire, though I spent a day cross-checking sources before I believed it myself.

Here's why it isn't a joke: the buyer stopped being a rocket company months ago. SpaceX absorbed xAI in February 2026, which put Grok and the Colossus data centers inside the same ticker as Starship. Read the deal that way and the absurdity evaporates — an AI lab just bought the developer distribution it could never earn on its own. That makes this the most consequential event in developer tooling since GitHub sold to Microsoft, and I think most of the coverage is aimed at the wrong layer. This was never an IDE story. It's the story of the most popular model-neutral coding tool becoming a wholly owned subsidiary of a company that sells a competing model. So, quick and to the point: the verified facts, one sharp judgment about what dies here, and the concrete moves worth making — because "wait and see" is only a strategy if you know what you're waiting to see.

The SpaceX Cursor Acquisition, Fact-Checked

A story this weird breeds embellished retellings fast, so before any opinion, the fact base. Every load-bearing claim below traces to CNBC, Forbes, NPR, CBS News, or an official company statement — not aggregator blogs.

(interactive diagram — view it on the original post)

Five details carry most of the weight:

The buyer is xAI wearing a spacesuit. SpaceX folded xAI into itself in February 2026, then went public on June 12 as SPCX — $75 billion raised, the largest IPO ever, at a $1.77 trillion valuation. Grok and Colossus were already inside the public company before the Cursor deal.
It was premeditated, not impulsive. Back in April 2026, SpaceX quietly locked in an option: pay roughly $10 billion for a partnership, or buy Anysphere outright for $60 billion later in the year. It exercised the buy side four days after listing. The IPO wasn't adjacent to the acquisition — it minted the currency for it.
It's all stock. Anysphere shareholders receive SpaceX Class A shares. Truell's statement: "SpaceX has exercised their option to acquire Cursor in an all-stock transaction with the goal of building the world's most useful AI models." Notice where that sentence lands — models, not editors.
Cursor is a serious business, not vapor. Roughly $4 billion in annualized revenue as of June 2026, up from $1 billion in November 2025; about $2.6 billion of that from enterprise B2B; 64% of the Fortune 500 on the customer list; over a million daily active users.
Public markets gagged on it. SpaceX stock popped 16% on announcement day — briefly making it the fourth most valuable US company — then reversed and shed roughly $600 billion in market value over four days as investors priced in the dilution and the focus risk.

Facts settled. Now the part that actually matters: what they mean.

Why a Rocket Company Buying an IDE Isn't a Joke

Start with xAI's position in early 2026, because it explains the whole transaction. The company had frontier-scale compute — Colossus 1 and 2 in Memphis — and almost no developer mindshare. One commenter on the Hacker News announcement thread was brutal about it: "xAI, a failed AI company which turned into a datacentre operator probably won't help." Unkind, but not wrong about the business mix. xAI's best-performing 2026 product is other people's workloads: Anthropic pays $1.25 billion a month for all of Colossus 1, and Google pays $920 million a month. Renting GPUs to your competitors is a fine business. It just isn't an AI strategy.

Cursor patches three holes with one signature. Distribution: a million-plus daily active developers and 64% of the Fortune 500, acquired overnight — a funnel Grok couldn't have built in a decade. Data: the interaction stream of working professionals — accepted edits, rejected suggestions, full agentic task traces — is arguably the best coding RLHF corpus outside Anthropic and OpenAI, and several HN commenters converged on this as the real prize: "the data they have flowing through the system is valuable for training." Revenue optics: $4 billion of fast-growing ARR looks terrific inside a freshly public company trying to justify a $1.7 trillion valuation with something other than launch contracts.

And if you're hoping the deal collapses under its own price tag, here's the uncomfortable math: $60 billion in post-IPO stock is close to free money. Fifteen times forward revenue is aggressive but not crazy by 2026 AI standards, and SpaceX paid in shares trading at a $2 trillion market cap — inflated paper for real revenue. The market's $600 billion tantrum says investors understood the trade perfectly: rational for Musk, dilutive for them.

I argued in my agentic coding trends piece that 2026 would consolidate the coding-tool market around whoever owns both the model and the harness. SpaceX just bought the biggest independent harness on the shelf. Which brings us to what actually breaks.

Model Neutrality Is the Real Casualty

Cursor's moat was never the editor. VS Code forks are a commodity — Windsurf proved it, and a dozen lesser clones proved it again. What Cursor sold was Switzerland: the one serious tool where a dropdown routed your task to Claude Opus, GPT, or Gemini, and where an enterprise could point sensitive code at whichever provider its compliance team already trusted. Ownership by a model vendor doesn't dent that neutrality — it deletes it, and no reassuring blog post rewrites the incentive math.

(interactive diagram — view it on the original post)

The panicked version of this take is wrong too, and worth killing: "Anthropic will cut Claude off from Cursor tomorrow, like it did to Windsurf." The Windsurf precedent is real — Anthropic yanked model access in 2025 while OpenAI was circling, on the plain logic that you don't arm a competitor buying your distribution channel. But this time the leverage runs the other way. Anthropic has committed roughly $15 billion a year of SpaceX-xAI compute through May 2029, taking over all of Colossus 1 and expanding into Colossus 2 — a commitment Anthropic itself announced as the thing funding higher Claude usage limits. When your landlord buys your biggest reseller, you don't torch the building. Mutual hostage-taking is the most underrated stabilizer in this industry.

So forget the cutoff. The realistic failure mode is erosion. The joint xAI-Cursor model — reportedly shipping as early as July 8, before the deal has even legally closed — becomes the default for new users. Grok gets the fast lane, the deepest agent hooks, the generous tier. Claude and GPT stay on the menu but drift upmarket: pricier tiers, slower capability rollouts, second-class agent support. Cursor already rehearsed this play with its in-house Composer model, which I took apart in my Cursor Composer 2 review — except Composer was a hedge, and the joint model is now the stated mission. Truell's own words: the goal is "building the world's most useful AI models."

The model picker used to be the product. It's about to become a migration funnel.

What Cursor Users Should Do Before the Deal Closes

Nothing changes in your editor this week, and anyone claiming otherwise is farming clicks — Anysphere operates independently until the Q3 close. But three clocks started ticking on June 16, and they determine what product you'll be using in December.

One: don't sign anything annual. The pricing pressure is structural, not hypothetical. SpaceX paid 15x forward revenue with stock the public promptly marked down by $600 billion, and the fastest way to fix that math is to squeeze more out of Cursor's enterprise book ($2.6 billion annualized) and its million-plus daily users. I can't prove prices go up; I can show you every incentive pointing that way — plus HN commenters with enterprise seats already reporting their orgs "have killed their cursor enterprise plans" within days of the announcement. Stay on monthly billing until post-close pricing lands. The option value costs a few dollars; prepaying for a product that changes owners and priorities mid-contract costs a year of regret.

Two: read the privacy fine print like it matters, because now it does. Cursor's enterprise pitch leaned hard on privacy mode and SOC 2 — your code goes only to the provider you chose, nothing retained. Under a parent whose stated goal is training "the world's most useful AI models," your interaction data stops being incidental and starts being strategic. Watch the privacy policy and the enterprise DPA for revisions between now and close. And if you work in defense, aerospace-adjacent, or any org with Musk-entity procurement restrictions — they exist, and they're more common than you'd think — compliance may make this whole decision for you.

Three: assume the defaults will move against you. The July 8 joint model is the tell. Onboarding, Auto mode, agent presets — all of it will tilt toward house models, because that tilt is what the $60 billion bought. If your workflow depends on picking Claude Opus for hard refactors — which, per my Cursor agent best-practices guide, is exactly what you should be doing today — you're the user this transition treats worst: the tool keeps working while your preferred configuration quietly gets more expensive and less supported.

Who Should Be Nervous: Winners and Losers

Player	Before June 16	After	Net
SpaceX-xAI	Frontier compute, no developer distribution	1M+ DAU funnel, Fortune 500 foothold, coding data stream	Big win (if it doesn't fumble the users)
Cursor founders/investors	Private, ~$30B valuation trajectory	$60B in liquid public stock; founders' net worth doubled	Enormous win
Anthropic	Powers much of Cursor usage; Windsurf precedent available	Its biggest IDE channel is now owned by a model competitor — that also happens to be its landlord	Complicated; Claude Code becomes the strategic hedge
OpenAI	Model supplier to Cursor, lost Windsurf bid in 2025	Weakest position: pure competitor with no compute entanglement	Loss
GitHub Copilot / Microsoft	Losing mindshare to Cursor all year	Inherits every enterprise that can't stomach Musk ownership	Quiet win by default
Windsurf	"Cursor but cheaper"	"Cursor but not SpaceX" — a much better pitch	Win
Developers	One great neutral tool	Neutrality gone; choice moves up a level, to which company you pick	Depends on what you do next

If you want the single most nervous party in that table, it's OpenAI: pure competitor, no compute entanglement, no leverage — locked out of the largest third-party surface for its coding models. Second most nervous is any enterprise with Musk-entity restrictions and a Cursor-shaped hole in its toolchain. And the quiet winners didn't lift a finger: Windsurf's pitch upgraded overnight from "Cursor but cheaper" to "Cursor but not SpaceX," while Copilot inherits every org that can't stomach the new owner.

The bigger industry read: the independent, model-neutral coding harness is going extinct. Every serious harness now belongs to a model vendor — Claude Code to Anthropic, Copilot to Microsoft/OpenAI, Antigravity to Google, and now Cursor to SpaceX-xAI. When I wrote Claude Code vs Cursor vs Windsurf in February, "Cursor is the neutral option" was a genuine differentiator; M&A just deleted that column from the comparison table. From here on, choosing a coding tool means choosing a model ecosystem. Make that choice on purpose, not by inheriting it from whoever buys your editor.

Should You Leave Cursor? A Decision Framework

Here's the framework I'd actually use, instead of the vibes-based "Musk bad, leave now" or "nothing ever changes, stay forever" takes flooding your feed.

(interactive diagram — view it on the original post)

My own position, since this blog exists to hold positions: I would not build a new team workflow on Cursor right now. Not because the product got worse — it didn't, and its agent tooling is still excellent — but because the stability of its assumptions got worse. Recommending a tool to a team means underwriting the next eighteen months of its roadmap, and Cursor's next eighteen months belong to integrating a trillion-dollar parent, shipping a house model, and justifying a $60 billion price tag. None of that work is for you.

For individuals, breathe. If Auto mode serves you fine, stay and enjoy it — with Colossus-scale compute behind it, the joint model may genuinely be strong. Just keep your setup portable: your .cursorrules, your MCP config, your prompts. The habits that make you effective in Cursor's agent transfer almost wholesale to Claude Code and Windsurf, which is exactly why switching costs less than it feels like it will.

The Bottom Line

The SpaceX Cursor acquisition is verified fact, rational strategy, and a eulogy for the one thing that made Cursor special — in that order. xAI bought distribution, data, and revenue with inflated post-IPO paper, and the bill lands on the users who valued Cursor precisely as neutral ground. A Windsurf-style instant cutoff probably never comes, because Anthropic's $15-billion-a-year compute entanglement makes cold war more profitable than hot war for everyone involved. What comes instead is slower and harder to headline: defaults shift, tiers reshuffle, and some morning in 2027 the model picker feels less like a menu and more like a suggestion.

You don't need to leave Cursor this week. You need to make leaving cheap — monthly billing, portable config, one weekend trial of an alternative — so that if the erosion arrives, exiting is an afternoon's decision instead of a quarter's migration. Tool loyalty made sense in an era when tools didn't change owners for $60 billion. That era ended on June 16.

DEV Community: Bruce He

CS146S Fall 2026: How to Watch and Follow Along Free

What "CS146S Video" Actually Gets You

The CS146S Fall 2026 Calendar

What's New in Fall 2026 vs Fall 2025

Free vs Enrollment-Only

The Follow-Along Plan: Each New Theme, Paired With a Tool

What You Lose by Not Enrolling

Where This Page Stops

Related Reading

ego lite Review: Handing Claude Code Your Logged-In Browser

What ego lite actually is, from the binary up

The receipts: three tasks, three tools, one model

Where the token win actually comes from (not the snapshot)

"Your logged-in browser" — half true, and the half that's false matters

Rough edges, in the order they cost me time

Verdict: use it, on a dedicated profile, with full access, on a Mac

FAQ

Related Reading

Series Navigation

Free AI Agent Courses Fall 2026: Stanford, CMU, MIT Compared

The Five Courses at a Glance

Which You Can Watch vs Which You Can Only Read

The Stack I'd Actually Run

Course by Course: What Each Is Really For

What's Not Free

Following From Outside the US

Where This Page Stops

Related Reading

CMU 11-768 AI Agents Fall 2026: Full Syllabus Breakdown

What CMU 11-768 Actually Is

Build, Evaluate, Train: The Spine of the Course

The Full 28-Session Schedule (Fall 2026)

Assignment 1 Up Close: Build the Thing You've Been Configuring

Who Should Take 11-768 vs CS146S vs CS329Z

The Five Lectures a Claude Code Power User Should Watch

How to Follow 11-768 Free, and When Videos Actually Drop

Where This Page Stops

Related Reading

pi Coding Agent Review 2026: 4 Tools vs Claude Code, Tested

What pi coding agent actually is (September 2026)

pi's four packages on the six harness layers

Hands-on: install, provider, and what a prompt costs before you type

Three identical tasks: pi vs Claude Code receipts

The 40-line extension, and how the model walked around it

Session tree: what /fork actually does

No sandbox, no permission dialogs: what it means for a team

Who should switch, who shouldn't

Rough edges from one day of use

Bottom line

Related Reading

External References

Stanford CS329Z Engineering AI Agents: Syllabus + Self-Study

CS329Z at a Glance

Why "Engineering" Is the Operative Word

The Full Fall 2026 Schedule

The Five Modules, and Where This Blog Already Covers Them

The Two Homeworks Are the Course

Self-Study Substitute, Module by Module

The Most Valuable Week for Readers of This Blog

What You Can't Get Without Enrolling

Verdict

Related Reading

gitui vs lazygit in 2026: Benchmarked on 82K Commits

The gitui vs lazygit benchmark: three repos, one harness

What 11 milliseconds actually buys you

Feature matrix from a week of real use

gitui vs lazygit for AI coding agents

Two things I hit that neither README mentions

Verdict: install lazygit, keep gitui for blame

Related Reading

Codex App Guide (2026): Setup, Workflows, and Real Pitfalls

What Is the Codex App in July 2026?

From Launch to Merger: Six Months of Whiplash

Installing and Setting Up the Codex App

Core Codex App Workflows: Threads, Worktrees, Parallel Agents

Codex App Pricing: What Every Plan Actually Gets

Codex App vs Codex CLI vs Claude Code

Six Pitfalls That Bite New Codex App Users

The Bottom Line