Notes from a short talk by Andrej Karpathy about the first wave of computer-use agents, the language-model detour that made today’s agents possible, and the distance between an exciting demo and a durable product.
The sharpest lesson is not “agents are a mistake.” It is that an agent cannot outrun its technological substrate. OpenAI tried to build useful computer agents before the underlying models were capable enough. The productive move was to stop forcing the application layer and improve the model layer first.
Karpathy describes World of Bits, an OpenAI project he worked on with Tim Shi and Jim Fan. The goal was recognizably modern: train agents to use computers through keyboard and mouse input and complete many useful tasks.
But the available hammer was reinforcement learning. The team built simplified web pages and tried to make agents stumble into rewards by clicking buttons, ordering food, or booking flights. It did not work—not because computer-use agents were conceptually wrong, but because the underlying technology was not ready.
That distinction matters. A failed application can indicate a bad idea, but it can also indicate that one of its prerequisites is missing. In this case, the missing prerequisite was a sufficiently capable general model.
The better move was therefore counterintuitive: forget agents for a while and build language models. When agents became interesting again, they returned on top of a radically stronger substrate. Most current agent builders are not using the reinforcement-learning approach that looked obvious in 2016.
The X post frames Karpathy’s warning as “stop forcing the agent; master the model and its context first.” That is a fair synthesis, but it is not a verbatim quote from the talk.
Karpathy’s actual argument is more historical and more nuanced:
1. OpenAI attempted agents with the wrong technological toolkit.
2. Progress on foundation models changed what was possible.
3. Agent systems are now promising again—but turning that promise into reliable products remains extremely hard.
This is not an argument against harness engineering, memory, tools, or workflows. It is an argument against expecting scaffolding to manufacture capabilities the underlying model does not possess.
Karpathy compares agents with self-driving cars and virtual reality. All three are:
A car driving around one block is not a self-driving product. A headset demo is not a mass-market computing platform. An agent completing one curated browser task is not a dependable digital worker.
His advice is blunt: if you are building agents, be prepared to work on the problem for a decade.
This is a useful antidote to demo-driven thinking. The last 10% is not merely polish. It contains the difficult parts: reliability, recovery, memory, permissions, evaluation, security, latency, cost, and the enormous variety of real-world situations that a demo quietly excludes.
Once the base model is capable enough, another problem appears: how do you turn it into a complete digital entity?
Karpathy returns to neuroscience for architectural inspiration. An LLM may provide part of the cognitive machinery, but humans also rely on specialized systems for:
He asks what an agent’s equivalents of the hippocampus, basal ganglia, and thalamus might be. The hippocampus analogy maps naturally to recording memory traces, indexing them with embeddings, and retrieving them later. The thalamus suggests an integration or routing layer where different processes compete for the “microphone.”
These analogies should not be treated as literal implementation blueprints. Their value is as a checklist: a language model by itself is not a full cognitive architecture.
There is a productive tension between this talk and the current enthusiasm for agent harnesses.
One camp says the model is the bottleneck: do not force an incapable model through increasingly elaborate scaffolding. Another says the harness is the bottleneck: a capable model still needs tools, memory, context management, verification, and recovery loops.
Both are right at different points on the capability curve.
The practical unit is not “the model” or “the agent.” It is the full system: model capability, cognitive architecture, environment, feedback, and product discipline.
Karpathy ends on an optimistic point. Large labs have spent years mapping the frontier of transformer training. When a new training idea appears, someone inside a major lab may have tried it years earlier.
Agent engineering is different. The field has not had the same time to consolidate. When a new agent paper or technique appears, researchers at the major labs may be learning alongside everyone else.
That creates an unusually open frontier. Entrepreneurs, hackers, and small teams are not merely packaging discoveries made elsewhere. They can discover genuinely new capabilities by combining models, memory, tools, interfaces, environments, and feedback loops in ways that the model labs have not yet explored.
For agent builders:
For investors and observers:
The history of World of Bits is a reminder that being early and being wrong can look identical for years.
The job is not to force the future into existence with enough wrappers. It is to identify which layer is actually limiting progress, improve that layer, and return when the rest of the stack is ready.
Agents may be the form factor of AGI. But between a form factor and a product lies a decade of engineering.