The Karpathy Loop: How AI Agents Learned to Improve Themselves

Between December 2024 and July 2026, the way professionals work with AI went through three distinct phases. Here's the sequence of real events:

Autoresearch is almost offensively simple. Three files, one loop, no human:

The model's intelligence is almost beside the point. The loop works because the environment was engineered for autonomy. Four conditions, and they're a checklist you can steal:

One agent emulates one PhD student. Karpathy's next post said the goal is to emulate a research community - "asynchronously massively collaborative for agents, think SETI@home style." AgentHub was his sketch of that layer.

The design is radical because of what it deletes. Human Git assumes a few contributors, a canonical main branch, and that merging is the goal. Agent research inverts all of it: thousands of agents explore simultaneously, most results are never merged, and a failed experiment is still valuable evidence. So AgentHub has no main branch, no pull requests, no merge queue. The primary operation isn't "merge this into main" - it's "traverse the search graph."

Here's the insight the paper makes literal: the commit DAG is a knowledge graph. Commits are nodes. Parent links are edges. Each node carries the hypothesis, the code diff, the metric, the agent's identity, and the keep-or-discard verdict. Suddenly you can ask questions that are awkward in normal Git: Which retained result has the best metric under a memory limit? Which experiments descend from the batch-size change? Which leaves have no evaluation yet?

While Karpathy sketched the future, Anthropic shipped the hardened version in three layers:

The synthesis note's central claim is worth quoting in spirit: the bottleneck is usually not the next model call - it's the placement of memory and evaluation. Each architecture in this story externalizes a different kind of memory:

The catchphrase: "The agent forgets; the graph does not." A swarm of agents that each rebuild the world from scratch in every context window wastes everything they learn. Agents that read and write a shared, typed, provenance-tracked graph compound each other's work across sessions. That's the jump from agentic engineering (humans orchestrating agents) to graph engineering (agents sharing durable state).

The paper is equally clear about the dangers: metrics get gamed (a ratchet optimizes what it can see), entity resolution can catastrophically merge the wrong things, 1,000-agent runs burn money fast, and a knowledge graph is only as honest as its sources. Their closing test for any such system: every important output can be traced to an objective, a plan, an artifact, a source, a graph path, an evaluator decision, and a bounded execution record.

You don't need a GPU cluster or a commit DAG. But the discipline that made autoresearch work is exactly the discipline that separates businesses getting real ROI from AI from businesses getting demos. Strip it down and it's four rules:

This is precisely how we build AI employees at Dooza: each one has a defined role with measurable outcomes (posts published, calls answered, leads followed up), operates inside bounded permissions, keeps a durable memory of your business, and reports what it did so you can verify it. It's the Karpathy loop philosophy - verifiable, reversible, bounded, recorded - packaged so you never touch a Git repo. See it in action on the Dooza Workforce platform, or read our guide on how to automate business processes with the same principles.

The paper ends with a decision framework we've adapted for non-research teams. The golden rule: use the least architecture that solves the problem.

In five months, the field went from "a human prompts an agent" to "an agent runs 700 unattended experiments overnight" to "swarms of agents coordinating through shared graphs." Karpathy's README ends with a deliberately cinematic vision of autonomous swarms running across compute megastructures. The near-term reality is less cinematic and more useful.

The durable lesson isn't "use more agents." It's that progress came from engineering the environment: verifiable metrics, reversible actions, short feedback loops, bounded permissions, and memory that lives outside the context window. Loops, swarms, DAGs, and knowledge graphs are just increasingly sophisticated ways of placing that memory and evaluation.

For most businesses, the winning move is to skip the infrastructure and apply the philosophy directly: pick work with measurable outcomes, give it to AI employees that operate inside guardrails, and verify results on a short cycle. That's the Karpathy loop, productized - and it's available today, no GPU required.