Andrej Karpathy on Software 3.0, LLMs as Operating Systems, and Partial Autonomy

Author: Andrej Karpathy

Andrej Karpathy’s keynote at YC’s AI Startup School in June 2025, published by YC as Software Is Changing (Again). He argues that large language models are a new kind of computer, programmed in English; that they resemble operating systems of the 1960s more than any other analogy; and that the products worth building now are partial-autonomy tools — ‘Iron Man suits’ that keep a human verifying the model’s work — rather than fully autonomous agents. The talk leans on slides [demonstration on screen].

What this talk covers

1. Software 1.0, 2.0, 3.0 (1:25) — code, then neural-network weights, now prompts in English; each paradigm eats part of the one before.
2. Utilities, fabs and operating systems (6:10) — three analogies for what an LLM lab is, of which the operating system fits best.
3. The 1960s of computing (11:04) — expensive, centralised, time-shared, and used through a text terminal with no general graphical interface yet.
4. The psychology of LLMs (14:39) — ‘people spirits’ with encyclopedic memory and cognitive deficits.
5. Partial-autonomy apps (18:22) — Cursor and Perplexity as models: context management, orchestration, a purpose-built interface, and an autonomy slider.
6. The generation–verification loop (23:40) — the AI generates, the human verifies, and the product’s job is to make that loop fast.
7. Tesla, Waymo and the Iron Man suit (26:00, 27:52) — why ‘the decade of agents’ is the honest timescale.
8. Vibe coding (29:06) — everyone is now a programmer; MenuGen’s code took hours and its deployment a week.
9. Building for agents (33:39) — documents and interfaces an LLM can read and act on.

Key concepts introduced

• Software 1.0, 2.0, 3.0 — 1.0 is code written for the computer, 2.0 is neural-network weights produced by an optimiser, 3.0 is prompts that program an LLM.
• LLM OS — the LLM as a CPU, the context window as its memory, the model orchestrating memory and compute to solve problems.
• Jagged Intelligence — superhuman in some domains, error-prone in ways no human would be, such as insisting 9.11 is greater than 9.9.
• Autonomy Slider — a control, owned by the user, over how much of a task the model does unsupervised.
• Vibe Coding — the term Karpathy coined, here described as a ‘gateway drug to software development’.

Key arguments

Prompts are programs. Karpathy calls prompts ‘programs that program the LLM’, written in English. At Tesla he watched neural networks absorb functions that had been hand-written C++ in the Autopilot stack, and the C++ was deleted; he expects Software 3.0 to eat through the stack the same way. A new engineer should be fluent in all three paradigms and choose among them per feature.

LLMs are utilities, fabs and, above all, operating systems. Labs spend capital to train a model, as a utility builds a grid, and sell metered access; when leading models go down, ‘it’s actually kind of like an intelligence brownout in the world.’ The training capital and centralised know-how resemble a chip fab. But the closest fit is the operating system: a few closed-source providers and an open-source alternative, apps that run on any of them, and a cost structure like computing in the 1960s — centralised, time-shared, and used through the equivalent of a terminal. One thing is new: the technology reached consumers before governments and corporations, reversing the usual order of diffusion.

LLMs are ‘people spirits’ with deficits. A model is a stochastic simulation of people, trained on human text, so it has an emergent, humanlike psychology. It has the memory of a savant (Karpathy cites Rain Man), but it hallucinates, is jagged, is gullible to prompt injection, and suffers from anterograde amnesia: it does not consolidate what it learns about an organisation, so its context window must be programmed directly as working memory. He points to Memento and 50 First Dates for the picture.

Build Iron Man suits, not Iron Man robots. The best LLM apps keep a human in the loop: they manage context, orchestrate several models, show the work in a purpose-built interface (a diff in red and green rather than a wall of text) and let the user set the degree of autonomy. Karpathy wants small, checkable increments — ‘it’s not useful to me to get a diff of 10,000 lines of code’ — because the human verifier is the bottleneck. His first ride in a self-driving car, in 2013, was flawless, and twelve years later driving is still unsolved; so when he hears that ‘2025 is the year of agents’, he answers that ‘this is the decade of agents’.

Build for agents as a new kind of user. MenuGen, an app he vibe-coded, worked on his laptop in a few hours; making it real — logins, payments, a domain, deployment — took a week of clicking through web consoles by hand. Hence the last section: agents are a third consumer of digital information, after humans using interfaces and programs using APIs. Karpathy suggests an llm.txt file analogous to robots.txt, documentation published as markdown, and replacing every instruction to ‘click’ with a command an agent can run (he cites Vercel and Stripe as early movers, and Anthropic’s Model Context Protocol).

YC’s transcript has a short gap in the Iron Man section, where a sentence breaks off and resumes mid-thought.

Relation to other talks

• From Vibe Coding to Agentic Engineering — a separate talk on the same Software 3.0 frame, which revisits MenuGen and concludes that the app should not exist at all.
• Intro to Large Language Models — the 2023 talk that first set out the LLM OS analogy.
• Andrej Karpathy on AGI Timelines, RL's Limits, and the Future of Education — the Dwarkesh interview, where ‘the decade of agents’ is argued at length.
• Boris Cherny on Opus 5, Deleting the System Prompt, and Giving Models Harder Problems — Startup School a year later: a builder arguing that newer models need less harness, not more.