Andrej Karpathy's AI-as-Operating-System Thesis, Unpacked
Karpathy puts the LLM in the kernel seat: context window as RAM, tools as syscalls, your files as storage. Useful as a lens for choosing tools this year, even if the metaphor does not survive the decade.
Andrej Karpathy argues the LLM is not a chatbot but the kernel process of a new operating system. Model weights are the CPU, the context window is RAM, tools and protocols like MCP are syscalls, and files are persistent storage. He has been sharpening this thesis since September 2023, most recently in his June 2025 talk on Software 3.0.
Where the thesis started, in his own words
The OS framing first appeared in a Karpathy tweet on September 28, 2023. The line everyone quotes: LLMs are emerging "not as a chatbot, but the kernel process of a new Operating System."
In the same thread he lists what the kernel already orchestrates: input and output across modalities, a code interpreter, browser access, and an embeddings database for files and internal memory. Six weeks later, in his November 2023 talk "Intro to Large Language Models," he drew the diagram. Context window as RAM. Tools as peripherals. The LLM as the process coordinating them.
By November 2023 he had also tweeted speculative specs: "LLM: OpenAI GPT-4 Turbo 256 core (batch size) processor @ 20Hz (tok/s) - RAM: 128Ktok - Filesystem: Ada002." The joke was the format. The argument was that this is the shape of the stack now.
What changed at YC AI Startup School in June 2025
Karpathy's keynote at Y Combinator's AI Startup School, delivered June 17, 2025, upgraded the framing to "Software 3.0." Software 1.0 is code humans write. Software 2.0, the 2017 essay, is neural network weights compiled from data. Software 3.0 is prompts in English that program the model directly.
In the same talk he compares LLMs to three things at once: utilities (huge fixed costs, metered access), semiconductor fabs (deep capex, deep moats), and 1960s mainframe operating systems running in the cloud with chat as the modern terminal. The OS analogy is no longer a sketch on Twitter. It is the load-bearing piece of how he describes the entire industry.
Karpathy is careful about what the OS is not yet. The LLM kernel does not have working multi-process coordination, mature security, robust long-term memory, or stable I/O. We are, in his framing, somewhere around the 1960s of this stack.
The mapping, piece by piece
If you accept the OS frame, the components line up cleanly.
The model weights are the CPU. They are fixed at inference time, expensive to produce, cheap to use per query, and they do the actual computation. The context window is RAM: short-term working memory holding what the kernel is currently processing. Anything outside it has to be paged in from somewhere else.
Tools are peripherals. Browser, code interpreter, image generator, calculator. Each one extends the kernel into a part of the world it cannot reach alone. The Model Context Protocol (MCP), released by Anthropic in November 2024, is the syscall standard: one shared interface so any LLM can call any tool without bespoke wiring. (For the detail on MCP itself, see What is MCP and Why It Matters for Your Business?.)
Files and folders are persistent storage. Vector databases are the disk index. Markdown is the assembly language of this OS because the kernel reads it natively. Karpathy formalised this in his October 2025 "LLM Wiki" gist: a structured markdown knowledge base that a coding agent compiles and queries on your behalf. The kernel reads, writes, and links the storage layer directly.
What it changes, if the thesis is right
The thesis predicts the death of the app as we know it. If the LLM is the layer through which work flows, software stops being a destination and becomes a tool the kernel calls. Cursor and Perplexity, in Karpathy's framing, are partial-autonomy apps: the user sits in a UI, the kernel does the work, the UI exists to show and verify.
Karpathy is explicit that this happens slowly. In the YC talk he said "this is the decade of agents," pushing back on every "2025 is the year of agents" headline. The mechanism he describes is an autonomy slider, borrowed from his Tesla self-driving work. You ship partial autonomy now. You move the slider right over years. Cursor's Tab-complete to agent mode is the example he keeps returning to.
He also told builders what to care about: design for the agent. Expose machine-readable documentation. Use markdown over PDFs. Add an llms.txt if you have a site. The argument is that LLMs are joining humans (GUIs) and traditional programs (APIs) as a third class of consumer for your software, and the third class is the one that scales.
There is a darker piece. Karpathy calls LLMs "people spirits": stochastic simulations of humans with encyclopedic recall, creative jumps, and serious cognitive deficits including hallucination, jaggedness, and amnesia between sessions. Simon Willison, whose blog Karpathy reads, has noted that this framing is the most useful single mental model in circulation right now. The kernel is fallible. The OS is built around a CPU that confabulates.
What this means for an SME choosing tools in 2026
If the OS is real, the choice that matters is what your kernel can see and call. Not which AI feature is on which vendor's roadmap.
In our work at Ellypsis with Danish small and mid-sized companies, the question that gets asked first is usually "should we buy Copilot or ChatGPT Enterprise?" The question that should get asked first is the OS one: where will work actually run, and does that layer have access to your data and your tools? If your CRM, your document storage, and your email cannot be reached by the layer where work happens, the answer to the licence question does not matter much.
Two practical implications. First, MCP support stops being a nice-to-have. It is the syscall layer of the kernel you are about to depend on. Ask every vendor whether they support it. Second, your documentation is now executable. Internal wikis, process docs, and decision logs in clean markdown become directly usable by the kernel. Process docs locked in PDF-only SharePoint folders are, for this purpose, dead storage.
The trap to avoid is treating the OS thesis as a buy signal for "AI platforms." There is no AI platform to buy. The kernel runs in the cloud, the storage runs in your existing systems, and the wiring between them is the work. That wiring is what an implementation actually is.
What stays unsettled
The thesis is a strong frame, not a settled fact. Several things could break it.
Memory is the obvious one. Today's LLMs forget between sessions in any reliable sense. A real OS has persistent process state. Until that is solved (and the research is early), the kernel restarts every conversation. Tool reliability is the second one: MCP servers are still inconsistent across vendors, authentication standards landed late, and the syscall layer is fragile in production. Karpathy's own 1960s analogy is honest about this.
The third is harder to name. The kernel hallucinates. A CPU that occasionally returns the wrong answer to a deterministic question is not a CPU. Wrapping a probabilistic model in OS metaphors might be the right framing for what the technology will be in ten years, or it might be the wrong frame entirely and we will look back on it the way we look back on the "information superhighway." We find the OS framing useful for picking tools today. We do not bet on the metaphor surviving intact through 2030.
What we do bet on: the components Karpathy is pointing at (a kernel that calls tools, a context window that is the bottleneck, a syscall protocol like MCP, a markdown-first storage layer) are the components Danish SMEs need to decide about this year. The metaphor may not last. The wiring choices do.
If you want the detail on MCP, the syscall layer this article keeps referring to: What is MCP and Why It Matters for Your Business?.
What is Karpathy's LLM-as-OS thesis in simple terms?
The thesis says LLMs are evolving into the kernel of a new operating system, not staying as chatbots. Model weights act as the CPU, the context window as RAM, tools as peripherals, and protocols like MCP as syscalls. Karpathy sketched it on Twitter in September 2023 and formalised it as Software 3.0 at YC AI Startup School in June 2025.
What is Software 3.0?
Software 3.0 is Karpathy's name for code written as English-language prompts that program large language models directly. It follows Software 1.0 (human-written code) and Software 2.0 (neural network weights compiled from data, his 2017 essay). The shift means natural language is now a real programming interface, and the LLM is the runtime that executes it.
How does the LLM-as-OS thesis relate to MCP?
The Model Context Protocol is the syscall layer in Karpathy's OS frame. If the LLM is the kernel, MCP is the standard interface through which the kernel calls external tools and reads data, much as system calls work in a traditional operating system. Anthropic released MCP in November 2024, and OpenAI, Google, and Microsoft have all adopted it.
Does Karpathy think AI agents will replace software?
Not soon. In his June 2025 talk he called the next ten years the decade of agents, and pushed back on the 2025-as-year-of-agents framing. He argues for partial autonomy: human-in-the-loop products with an autonomy slider that moves right over years. Cursor and Perplexity are his example shape, not fully autonomous agents that run unsupervised.
What should a small or mid-sized company do with this thesis?
Use it to ask better questions. Instead of asking which AI tool to buy, ask what the AI layer can see and call inside your business. Make sure your vendors support MCP. Move documentation into clean markdown the model can read. Treat the wiring between AI and your existing systems as the implementation work that matters.