Andrej Karpathy reframes large language models (LLMs) as a new kind of computing substrate and divides software history into three eras. Software 1.0 was hand-written source code, Software 2.0 was characterized by learned weights produced by machine learning, and Software 3.0, he argues, treats programs as pieces of text — prompts and context — interpreted and executed by agents. According to Karpathy, this shift changes both how software is authored and how users interact with it.
OpenClaw as an example of agent-native software
Karpathy’s clearest illustration is OpenClaw. Rather than shipping a massive install script intended to handle every machine and edge case, OpenClaw provides a block of instructions that a user can hand to an agent. The agent reads the environment, performs debugging, and completes the installation intelligently, adapting to local conditions instead of relying on a one-size-fits-all script.
What changes in practice
In the traditional model, software must encode every branch, platform-specific case, and failure mode ahead of time. In the Software 3.0 model, the ‘‘program’’ can be a text prompt, the interpreter is the LLM, and the runtime is an agent using tools inside the user’s environment. This is more than embedding AI in software — it is software becoming agent-native and delegating operational complexity to an intelligent runtime.
Implications: intent-driven interfaces and adaptive products
Karpathy suggests this approach points toward a post-app stack. Where Software 1.0 required humans to write explicit instructions for machines, Software 3.0 allows humans to express intent for agents to carry out. Products therefore shift from fixed workflows to adaptive collaborators: users no longer operate apps in the same way, but instead trust agents to operate on their behalf.
Summary
Karpathy’s framing positions LLMs and agents together as a new runtime in which the program is text, the interpreter is the large language model, and the agent performs actions in the local environment. OpenClaw demonstrates how an agent can replace a monolithic install script by inspecting and adapting to the host system, offering a preview of how future software might be authored and used.
