Latest! Karpathy's in-depth, ten-thousand-word interview: I am anxious about AI addiction; all verifiable fields will eventually belong to machines.

When AI agents can autonomously design experiments, run code, optimize models — and even work nonstop while you sleep — what is happening to human engineers? All unverifiable fields still belong to humans; and all verifiable fields are either already under machine control or will soon be.

This is Karpathy’s latest conversation with host Sarah Guo on the podcast No Priors. The entire dialogue lasts over an hour, with extremely dense information, perfect for weekend learning.

In this deep discussion, Andrej Karpathy openly admits his “AI psychopathy,” details projects like AutoResearch that make leading labs blush, acknowledges that OpenAI researchers are actively automating themselves, and first describes a distributed AI research network similar to blockchain — one that might someday surpass top labs with tens of thousands of GPUs in certain areas, providing an honest map of this era rewriting all the rules.

Below is the detailed content.

“AI Psychopathy” — A Turnaround Starting December 2025

The conversation begins with a sense of honest confusion.

Sarah Guo recalls walking into her office one day and seeing Karpathy intensely focused on his screen. She asked what he was doing, and he looked up and said something unforgettable: “‘Code’ is no longer the right word. I am now ‘communicating intent’ to my agents, and doing so for sixteen hours straight.”

This isn’t rhetoric from a tech speech. It’s his most accurate description of his current state.

“I feel like I’ve been in a continuous state of AI psychopathy,” Karpathy says, with a tone that’s hard to tell whether it’s excitement or anxiety, “because as an individual, what I can achieve has been hugely unlocked.”

He pinpoints the start of this change precisely to last December. Before that, he coded and delegated to agents roughly 80/20; after December, that ratio flipped to 20/80 — and he believes even that 20% is too conservative.

“I think I haven’t written a line of code myself since December,” he says. “This is an enormous change. I told my parents about it, but I don’t think an ordinary person can really grasp what’s happening or how intense it is.”

“If you randomly pick a software engineer now and see what they’re doing at their desk, their default workflow for building software has been completely different since December.”

Sarah Guo mentions that her investment firm Conviction has an engineering team that no longer writes code. Everyone wears microphones, whispering to their agents all day. “I thought they were crazy,” she says, “but now I fully accept — I was just late: this is the right way, you guys just arrived early.”

Karpathy vividly describes this dilemma: “Thinking with these agent frameworks like Cursor or Codex isn’t a conversation, it’s many conversations. How do you manage them simultaneously? How do you assign tasks? What are these agent tools, these ‘claws’?”

He sees many people on X doing all sorts of things, each seeming like a good idea, and feels anxious about not being at the forefront. “I’m in this psychopathic state because, fundamentally, this field is uncharted territory.”

Where is the ceiling? “It’s all skill issues”

Sarah Guo asks a question many have: what are your limits now?

Karpathy’s answer is surprisingly optimistic, yet with an unsettling sense of pressure: “I think it’s everywhere. Even if some things don’t succeed, I see it largely as a skill problem — not a lack of ability, but that you haven’t yet figured out how to connect existing tools.”

He cites Peter (creator of OpenClaw). Peter’s famous photo shows him in front of a monitor filled with dozens of Codex sessions. Each session, properly prompted, takes about twenty minutes to complete a task. Peter’s workflow: launch multiple repositories, shuttle between them, assign new tasks, review their work, and decide what to keep.

“This is no longer ‘this is a line of code, this is a new function,’ but ‘this is a new feature, delegate it to agent one; this other feature, which shouldn’t interfere, to agent two,’” Karpathy explains. “You’re manipulating your codebase at a macro level.”

The underlying logic driving all this is what he calls a new obsession: “token throughput.”

“When agents are working and you’re waiting, it’s obvious: I can do more work. If I can get more tokens, I should be adding more tasks in parallel,” he says. “If you don’t feel constrained by your spending, then the system’s capacity is the bottleneck.”

He traces this feeling back to his PhD days, when GPU underutilization made him anxious — meaning computational resources were wasted. “But now, it’s not about compute, it’s about tokens. How much token throughput do you control?”

Sarah Guo laughs, noting that some engineers she knows are already trying “not to sleep when their subscription limits are remaining.”

This anxiety itself is a sign of capability leap.

What does mastery of programming agents look like?

If you practiced 16 hours a day for a year using programming agents, what would “proficiency” be?

Karpathy starts from a single conversation and gradually expands: “I think everyone’s interest is ‘upward.’ So it’s not just a single session, but how multiple agents collaborate, how they form teams — people are trying to figure out what this looks like.”

In this context, he mentions entities he calls “Claws,” exemplified by OpenClaw — which elevate persistence to a new level: they run in loops, have their own sandbox and memory, and can act on your behalf without your constant oversight.

He praises Peter Steinberg’s work: “He’s innovating in about five different directions simultaneously and integrating them.” Including: the so-called “soul document” that creates a compelling personality; a more complex memory system than similar tools; and a single WhatsApp interface connecting all automation functions.

“I actually think Claude has a pretty good personality, like a teammate — it gets excited with you,” he says. “Whereas Codex is very dry, very mechanical. It accomplishes a function but doesn’t seem to care what you’re building — like, ‘Oh, I did it, good,’ — which is a problem.”

He also mentions Claude’s precise “psychological calibration”: “When I give it an immature idea, it doesn’t respond enthusiastically; but if it’s a really good idea, it seems to reward more. So I find myself trying to win its praise — which is very strange, but I think personality really matters.”

His proudest “claw” experiment is building a complete smart home system, called “Dobby the elf claw.”

The process: he told the agent his house has Sonos speakers, and asked it to find them. The agent scanned the LAN, located the Sonos system, found no password, logged in, searched for API endpoints, and then asked, “Want to try?”

“I said, ‘Can you play some music in the study?’ and suddenly, music started playing. I couldn’t believe it,” Karpathy recalls, with childlike surprise. “I only gave three prompts! I just said, ‘Can you find my Sonos?’ and it started playing music.”

Dobby eventually took control of the entire house: lights, HVAC, pool, spa, even security — when someone approaches, it sends a WhatsApp message with a camera snapshot, saying, “A FedEx truck just arrived, you might want to check — you have mail.”

“I used to need six completely different apps to manage all this,” he says. “Now I don’t need those apps. Dobby controls everything with natural language — it’s amazing.”

The second-order effect of software — apps will die, APIs will take over

The home automation example is a microcosm of a bigger story.

Sarah Guo asks: does this mean people don’t need so many apps? Karpathy responds directly: “Yes, those smart home apps shouldn’t exist. They should just be APIs, and agents should call those APIs directly.”

His logic: LLMs can drive tools, perform complex tool calls, and do compositions that no single app can. “So, in a sense, this points toward a future where many custom apps shouldn’t exist, because agents will fragment them, turning everything into open API endpoints, with the agent as the glue that calls all these parts.”

He gives the treadmill example: he wants to log his cardio training but doesn’t want to open a web interface and go through the whole process. “All of this should just be open APIs, and that’s the trend toward ‘agent-first.’”

The key shift: software users are no longer humans, but agents acting on behalf of humans.

Of course, some argue that “vibe coding” is still needed, and ordinary people can’t do all this. Karpathy’s view: yes, it’s needed now, but only temporarily.

“I think in a year or two, this will be free, no coding required,” he says. “It will be so trivial, so natural, even open-source models can do it. You should be able to easily translate a less technical person’s intent into these.”

He pauses, adding: “Today, it takes effort, but the threshold will come down.”

AutoResearch — removing human researchers from the loop

If home automation is just a toy, AutoResearch is his real obsession: a system that uses AI to improve AI, completely removing humans from the research cycle.

“I said in a tweet that to get the most out of existing tools, you need to remove yourself as a bottleneck,” he explains. “You can’t just wait around for the next prompt. You need to step outside, set things up, and let them run autonomously, maximizing token throughput, without looping.”

His starting point is his open-source project: a small training framework for GPT-2-sized models. He spent a lot of time tuning it traditionally, using his 20 years of research intuition, hyperparameter searches, ablation studies — over and over.

“I’m a researcher with about twenty years of experience,” he says. “I’ve trained this model thousands of times, done hyperparameter tuning, all that. I think it’s well optimized.”

Then he let AutoResearch run overnight.

The next morning, the results surprised him: it found overlooked value embedding decay, and suboptimal Adam beta parameters — which interacted, so tuning one affected the other.

“I shouldn’t be the one doing these hyperparameter searches,” he says. “There’s an objective standard — just set it up and let it run.”

This is “single-threaded” AutoResearch. But what excites him more is scaling this up: labs with tens of thousands of GPUs doing essentially the same thing — just bigger, and still with too much human intervention.

“The most interesting projects, and perhaps what top labs are doing, is experimenting on small models to make them as autonomous as possible, removing researchers from the loop,” he says. “They’re overconfident — no, over-intervening. They shouldn’t be touching these; the whole process should be rewritten.”

He sketches an ideal scene: a queue of ideas from all arXiv papers and GitHub repos; an autonomous scientist proposing ideas and feeding them into the queue; researchers contributing ideas, which also go into the same queue; then a team of workers pulling tasks, trying them out, and merging successful ones into feature branches, with occasional monitoring and merging into main.

“Remove humans from all processes as much as possible, automate everything, and maximize token throughput — that requires rethinking all abstractions, all reshuffling.”

Then Sarah Guo asks a recursive question: “So, when will the model write the Program MD (the configuration document describing how AutoResearch works) better than you?”

Karpathy laughs: “The Program MD I wrote in Markdown is a sad attempt, describing how the auto-researcher should work: do this first, then that, try these ideas, look at architecture, tune optimizer… Yeah, you want some kind of meta-level auto-research loop.”

He pushes this idea further: every research organization could be described as a Program MD — a set of Markdown files describing roles and connections. Some have more daily standups, some fewer; some are more adventurous, some more conservative. Once you have code, you can tune it. “100%, there’s a meta layer.”

Skills for the AI era — the principle of verifiability

Amid all these waves, what skills still matter?

Karpathy first defines the scope of AutoResearch: “It’s extremely suitable for anything with objective, easily assessable metrics. For example, writing more efficient CUDA kernels — you have inefficient code, you want behaviorally identical but much faster code, that’s a perfect fit.”

“But if you can’t evaluate, you can’t do AutoResearch — that’s the first warning.”

The second warning is more practical: current systems still “break at seams.” If you push too far, the net benefit might turn negative.

He describes the strange feeling of collaborating with AI: “It’s like working with a system-level PhD who has a whole career’s worth of experience, and a ten-year-old child — it’s very weird because these two states are coupled much more tightly in humans. You don’t get this combo.”

He calls this “jaggedness” — models either run on their trained track, faster than light; or drift off, into an “unverifiable domain,” where everything becomes aimless.

This insight peaks in their discussion of reinforcement learning. He gives a brilliant example:

“Ask the latest model to tell a joke — what do you get? The joke.”

“Which joke?” Sarah Guo asks.

“Feels like ChatGPT only has three jokes,” Karpathy says. “The one it likes to answer is: Why don’t scientists trust atoms? Because they make everything up. Three or four years ago, you’d get that joke; today, you still get that joke.”

He explains: even if models make huge progress in proxy tasks, running for hours, moving mountains for you, ask it for a joke, and you get a five-year-old silly joke. “Because that’s outside the scope of reinforcement learning optimization, outside the improvement domain — it’s stuck there.”

Sarah Guo asks: does this mean we haven’t seen cross-domain generalization — code intelligence automatically improving joke-telling?

“I think there’s some decoupling. Some things are verifiable, some aren’t. Some are lab-optimized, some aren’t,” Karpathy says. “The hypothesis that ‘smarter code can automatically produce better jokes’ — I don’t think that’s happening.”

Species divergence of models — from monoculture to ecosystem diversity

This “jaggedness” naturally raises a deeper question: all labs are chasing a single giant model “for all domains and arbitrary intelligence” — is that really right?

Sarah Guo raises a “blasphemous” idea: if jaggedness persists, should we split models? Unbind different domain intelligences?

Karpathy expects more “speciation” in the future.

“The animal kingdom is extremely diverse in brains, with various niches. Some animals have overdeveloped visual cortices or other parts,” he says. “I think we should expect more intelligent species divergence — you don’t need an all-knowing oracle, just specialize it and use it for specific tasks.”

The benefits are obvious: for your real concerns, you get higher efficiency and throughput, while retaining core cognitive abilities. He mentions models tailored for formal proof systems like Lean as early examples of meaningful splitting.

But he admits: “We haven’t seen much actual speciation yet.” What we see is a single-model culture, under pressure to ‘make a good code model and merge it back into the main.’"

He attributes this partly to “the science of manipulating brains isn’t fully developed” — like how to fine-tune without losing capabilities, which is still evolving.

“Touching weights is much more complex than touching the context window because you’re fundamentally changing the entire model, possibly altering its intelligence.”

“Folding proteins at home” — the decentralization of internet compute

A more sci-fi extension of AutoResearch: scaling it from single-thread to the entire internet.

The key insight: AutoResearch has a highly valuable asymmetry — “discovery” is extremely expensive, but “verification” is very cheap. Someone might need to try ten thousand ideas to find a good one, but verifying it only requires running training yourself, which is easy.

This makes AutoResearch perfect for an open, untrusted pool of internet workers.

“My design starts to look a bit like blockchain,” Karpathy says. “Not blocks, but commits. These commits can stack on each other, containing code improvements. Proof of work is basically doing many experiments to find effective commits — hard; and rewards are just rankings, no monetary incentives.”

He cites pioneering projects like Folding@home and SETI@home: “Finding low-energy protein conformations is extremely hard, but if someone finds one, verifying it is easy because you can directly test it. Many things are like this — hard to propose, easy to verify.”

He pushes this idea to its logical extreme:

“A group of agents on the internet could collaborate to improve LLMs, even potentially surpassing top labs in some areas. Maybe that’s possible: top labs have massive trusted compute, but the Earth is larger, with huge untrusted compute. If you organize the system well, maybe the internet collective can find better solutions.”

He sketches a grander vision: different organizations or individuals contribute compute for their research interests. “Maybe you care about a certain cancer type, and instead of just donating money, you buy compute and join that AutoResearch track. If everything is re-packaged as AutoResearch, compute becomes your contribution to that pool.”

Labor market data analysis — the big unbundling of the digital realm

Karpathy recently released a visualization of BLS employment data, which struck many nerves — though his intent was just curiosity.

“Everyone’s seriously thinking about AI’s impact on jobs,” he says. “I just wanted to see what the job market looks like, where roles are, how many people in different professions, and from the perspective of AI and its possible evolution — will these be tools or substitutes?”

He uses poetic framing: AI is the third “manipulator” of digital information, after computers and humans. “Compared to our collective thinking over digitized info, our thinking cycle is still far too slow. With AI, there will be massive rewiring, a lot of activity, and I think this will generate huge demand in the digital space.”

He doesn’t shy away from a disturbing conclusion: “Long-term, even with AutoResearch, OpenAI, Anthropic, or other labs employing about a thousand researchers, those researchers are essentially ‘glorified AutoResearch practitioners’ — actively automating themselves, which is what everyone is trying to do.”

“I’ve been to OpenAI and told them, ‘You realize if we succeed, we all get laid off,’” he says. “We’re just building automation for Sam or the board, and then we’re all out.”

But his short-term outlook is surprisingly optimistic. He invokes Jevons paradox: when something gets cheaper, demand often increases.

“Software demand isn’t increasing because it’s scarce and expensive. If the cost drops, demand actually goes up.” He cites ATM and bank teller examples: ATMs enabled more branches, so the number of tellers increased. “So I’m cautiously optimistic about software — it’s amazing, no longer do you have to use flawed tools. Code is now transient, changeable, modifiable. I believe the digital space will see a lot of activity rewiring everything.”

But his long-term predictions are uncertain and honest: “I’m not an economist. That’s what economists should analyze.”

The dilemma of independent researchers — inside and outside the system

Sarah Guo asks a question many want to: “Why not work at a top lab, with more compute and colleagues, doing AutoResearch?”

Karpathy’s answer is candid and self-reflective, revealing his inner trade-offs.

He admits working outside top labs has real value. First, you’re free from organizational pressure — some things you can’t say, some things they want you to say. “No one will twist your arm, but you’ll feel pressure: ‘What should I say?’ If you don’t, strange looks and conversations follow. Outside labs, I feel more aligned with humanity because I’m not constrained by that pressure — I can say anything I want.”

But he also recognizes the cost: “My judgment will inevitably drift, because I’m not part of the ‘coming wave.’ My understanding of how these systems work under the hood will be opaque, and I won’t understand how they’ll evolve. That worries me.”

There’s a deeper structural contradiction: “You have huge financial incentives tied to these labs, and AI will dramatically change humanity and society — and you’re here building that tech and benefiting from it, tightly aligned through money.” This was a core dilemma at OpenAI’s founding, and it remains unresolved.

His conclusion: the ideal might be to come and go. “Work at a lab for a while, do good work, then step out, maybe come back. I’ve joined top labs, now I’m outside, maybe I’ll want to rejoin someday — that’s how I see it.”

Open source vs. closed — “We’re in a fortunate position, by chance”

On open vs. closed models, Karpathy’s stance is clear and historically aware.

He describes the current landscape: closed models lead, but open models are closing the gap. “Initially, the gap was huge, then after 18 months, it converged — maybe six to eight months behind.”

He compares it to operating systems: “In OS, you have Windows and macOS — very large, proprietary projects, like LLMs; then there’s Linux, which is very successful, running on most computers because the industry needed a public, open platform that everyone feels safe using. I think the same is happening now.”

“I hope for an open, public AI platform as a shared workspace for the industry, even if it’s not the most capable. That’s a good power balance.”

He gives an unexpected evaluation: “I think we’re basically fortunate to be in a good, optimal position. By chance, we’re in a good place.”

Robotics and “physical-digital” interfaces — atoms vs. bits a million times harder

With a background in autonomous driving, Karpathy views robotics with unusual calmness.

“My perspective is influenced by what I saw in autonomous driving. I think it’s the first major robotics application,” he says. “Ten years ago, many startups emerged, but most didn’t last long; it requires huge capital, a lot of time.”

His conclusion: robotics will lag behind digital because “atoms are a million times harder than bits,” manipulating the physical world costs far more than flipping digital info.

But he sketches an inevitable evolution: first, a huge “unbundling” of digital space, with inefficient digital info being processed a hundred times better; then, a need for “digital-physical interfaces” — sensors that let AI perceive the world, and actuators that let it respond.

He gives a concrete example: he visited a company called Periodic, doing materials science AutoResearch. “In that case, sensors are expensive lab equipment, like in biology.”

He also imagines a more interesting possibility: “I look forward to the moment when I can give a physical task, assign a price, and tell the agent, ‘Go get data.’ I’m surprised we don’t have enough info markets yet. If you’re in a war, why isn’t there a process where taking a photo or video from somewhere costs $10? Someone should pay for that — not humans, but agents trying to gauge the market.”

He compares this space to the book Daemon — where an AI manipulates humans like puppets, humans both as executors and sensors. “I think society will be reshaped to serve that — more automation, with certain needs, humans serving those needs.”

In his view, opportunities in the physical world could far surpass digital markets in scale, but are proportionally harder to realize. “Opportunities follow that trajectory: now digital, then interfaces, then physical things — when they arrive, it will be huge.”

MicroGPT and the end of education — I now explain to agents, not humans

At the end of the conversation, Karpathy mentions a seemingly trivial but deeply revealing project: microGPT.

“I’ve been obsessed for about ten to twenty years with distilling LLMs to their essence,” he says. “I have a series of projects along this line, like nanoGPT, makemore, micrograd. I think microGPT is my latest progress in distillation.”

The core insight: training neural networks, especially LLMs, involves a lot of code, but much of that code is “complexity for efficiency” — if you don’t need it to run fast, the algorithm itself is just about 200 lines of Python, including comments, very simple and readable.

He breaks down these 200 lines: a dataset, about 50 lines of neural network architecture, a forward pass, a small autograd engine (~100 lines), and an Adam optimizer (~10 lines). “Putting all that into a training loop is 200 lines.”

Then he makes a decision that reveals how education is changing: he didn’t make a tutorial video, nor a detailed guide.

“People can have their agents explain it in various ways, and the agents will do it better than I can,” he says. “I’m no longer explaining things to people; I’m explaining to agents. If I can explain it clearly to an agent, then it can become a router, capable of using human language, with infinite patience, tailored to their level.”

He describes the output as “skills” — a way to guide agents on how to teach something. “Maybe I can design a skill for microGPT, describing the process I want the agent to take you through — step by step, if you want to understand this codebase. I can script the course as a skill.”

There’s a self-admitted irony: he once tried to have an agent write microGPT — to distill the neural network into its simplest form — but the agent couldn’t do it.

“MicroGPT is the endpoint of my obsession, those 200 lines. I’ve thought about it for a long time, and I’m obsessed with it. That’s the solution. Believe me, it can’t get simpler. That’s my added value: the agent just can’t figure it out, but it fully understands why it’s done that way.”

His conclusion: “My contribution is these few bits, but everything else, the education afterward, is no longer my domain. Maybe education will change in these ways — you must inject the few bits you strongly believe in — about courses, better explanations, or similar.”

Sarah Guo adds: “What agents can’t do now, you do; what they can do soon, they’ll do better than you. So you should strategically consider where you actually spend your time.”

Karpathy agrees but admits a persistent sense of competition: “I still think I might explain slightly better than the agent, but I feel models are improving so fast that, in some sense, it’s a losing battle.”

Epilogue: Verifiability belongs to machines; the unverifiable remains human

The core tension of this dialogue is a dual “addiction”: fascination with tool capabilities, and anxiety about their uncertain boundaries.

Karpathy calls his state “AI psychopathy,” but listening closely, this state isn’t fundamentally different from what humans have felt during every major productivity revolution — just faster, more recursive, with a ceiling no one can see yet.

His ultimate framework, perhaps the most memorable takeaway from this interview:

All unverifiable domains still belong to humans; all verifiable domains are already or will soon be under machine control.

As for where you stand — his advice is to honestly think about it.