Autoresearch was one of the dominant themes at ICML 2026 in Seoul last week. A year ago the term barely existed. This year it was everywhere. Google used its expo slot to present an end-to-end AI Scientist, complete with a sub-agent that checks a claim's novelty against the historical literature and another that generates the paper's figures. A workshop spent a full day debating whether these systems are tools, co-authors, or founders. An oral argued that we should stop automating peer review until we can evaluate it, after showing that AI reviewers agree with each other too readily and can be swayed by rewriting a paper's prose. A hackathon track had agents write complete ICML-format papers that a panel of eleven human reviewers scored. And a large fraction of the strongest work — including the benchmarks our keynote Kilian Lieret builds — was really about the same question: once agents can generate research at scale, how do we tell what is real?

Most of this traces to one artifact. In March 2026, Andrej Karpathy released a 630-line repo, autoresearch; within weeks it had tens of thousands of GitHub stars, Fortune had dubbed the pattern "the Karpathy loop," and Shopify's CEO had used a variant to speed up production code overnight. Since then the loop has been pushed in two directions: across the research pipeline — from generating an idea to running the experiment, writing it up, and reviewing it — and up levels of abstraction — from tuning a solution, to reshaping the agent's own scaffold, to changing how it searches.

This primer covers what the loop is, where it came from, where it is going, why verification is the binding constraint, which parts of the stack now matter, and how we have organized the build day. Our guests map onto the field: Pushmeet Kohli leads AI for Science at DeepMind (the loop pointed at discovery), Jerry Tworek left OpenAI in January to start Core Automation, a lab focused on automating research itself (the loop pointed inward), and Kilian Lieret at Meta FAIR built SWE-bench and SWE-agent (the evaluation backbone that decides whether any of it works).

Autoresearch is one keep-or-revert loop

The loop is the same everywhere: propose a change, run it, score it against an objective, keep it if it beats the best so far, revert it if not. The human writes the objective and constraints; the agent runs the experiments.

Karpathy's repo is the cleanest reference — now a few months old, so treat it as the minimal case. Three parts:

  • train.py — a small but real nanoGPT-style training script; the agent may edit anything (architecture, optimizer, attention, hyperparameters).
  • a scoring script — computes the single metric (validation bits-per-byte) and is off-limits, so the metric cannot be gamed.
  • program.md — the directions to explore and the constraints to respect.

Every run trains for a fixed five minutes, so roughly a hundred experiments happen overnight. Improvements are committed to git; regressions are reverted. The fixed budget is the key design choice: it makes runs comparable, and it forces a win to be an efficiency gain rather than more compute.

What made the repo spread is that the pattern works on anything you can score. Within weeks the community had pointed it well past ML training: Shopify's Tobi Lütke ran a variant against Liquid, the twenty-year-old Ruby engine behind millions of storefronts, and reported a 53% render speedup across 93 automated commits — widely discussed, though flagged by some as possibly overfit and never merged. Others applied it to a query-expansion model that came back smaller and faster than the one it replaced, to GPU-kernel throughput, to voice-agent prompts, and to hardware ports for Apple Silicon and consumer GPUs. A few ran the loop on the autoresearch harness itself.

The research frontier is moving in two directions

Everything past Karpathy's minimal case relaxes one of his limits, in one of two directions.

Across the research pipeline. The loop is now applied at each stage of how research gets done:

  • Experiment execution — the most mature stage: agents set up code, run and monitor experiments, and keep what improves.
  • Idea generation — the weakest stage: models hold enormous knowledge but little judgment about which directions are worth pursuing.
  • Paper writing — agents that draft first, then make each claim true through verification.
  • Review — agents that critique drafts and flag reproducibility gaps, plus research on where AI review breaks down.

Up levels of abstraction. The loop is allowed to edit more of itself:

  • The solution — edit the training script (the original case).
  • The harness — optimize the agent's own prompts, memory, and tool routing across a family of tasks.
  • The search — rewrite how it explores, for instance an outer loop that injects new search mechanisms into the inner loop.
  • The improver — a loop that improves its own ability to improve: recursive self-improvement. Results here are early, and no one credible claims a runaway effect.

Two of the largest efforts map onto this without forcing. Algorithm and math discovery at DeepMind is the group Kohli leads; automating AI R&D itself is the thesis behind Tworek's Core Automation. The loop has also moved beyond the datacenter, into wet-lab biology and even onto physical robots.

The loop didn't come from nowhere

The pattern is new; its ingredients are not. A short timeline of the work it stands on, with the lab or university behind each:

  • 2021 — AlphaFold 2 (Google DeepMind). Deep learning cracks a hard scientific problem end to end; Nobel Prize, 2024.
  • 2021–22 — Codex (OpenAI) and AlphaCode (DeepMind). LLMs write functional and competition-level code — the substrate every code-editing agent runs on.
  • 2023 — Coscientist (Carnegie Mellon) and A-Lab (Berkeley), both in Nature. Autonomous labs plan and run real chemistry and materials experiments.
  • 2023 — Reflexion (Northeastern and Princeton). Agents improve by critiquing and remembering their own failures.
  • 2023–24 — FunSearch (Google DeepMind, Nature). LLM-guided program search finds genuinely new mathematical results.
  • 2024 — Self-Rewarding Language Models (Meta and NYU). A model generates and grades its own tasks, closing an automated feedback loop.
  • 2024 — The AI Scientist (Sakana AI). The first system to run the full pipeline from hypothesis to written paper.
  • 2024 — SWE-bench and SWE-agent (Princeton, our keynote's work). A verifiable benchmark of real GitHub issues, and the first open agent to make real progress on it — the evaluation substrate the field now leans on.
  • 2025 — AI Co-Scientist (Google DeepMind). Multi-agent hypothesis generation and ranking.
  • 2025 — AlphaEvolve (Google DeepMind). The loop turned into deployed algorithmic and mathematical discoveries.
  • 2025 — Darwin Gödel Machine (Sakana AI with Jeff Clune's lab at UBC). An agent that rewrites its own code under empirical evaluation — the clearest self-improvement archetype so far.
  • 2025–26 — Robin and Kosmos (FutureHouse). End-to-end biological discovery; Robin reached Nature in 2026.
  • March 2026 — autoresearch (Karpathy). The idea stripped to 630 lines anyone could run overnight, which is why the wave broke this year.

What today's systems tell us

The current crop is not a random zoo. Sort the systems by what they optimize and you can read off where the field is confident and where it is guessing.

Where verification is cheap, discovery is real. The strongest results cluster in domains with exact, automatic scoring — code and math — and get shakier as they reach into the physical world:

  • AlphaEvolve (DeepMind) pairs an LLM with automated evaluators and evolutionary search; it found a faster 4×4 complex matrix-multiply and improved several open math bounds.
  • AI Co-Scientist (DeepMind) and Sakana's AI Scientist run the discovery pipeline, but on questions no automatic grader can settle, so a human still has to judge the output.
  • FutureHouse Robin and Kosmos reach real biology, where the bottleneck is not the agent but the wet lab: the AI proposes in minutes and the experiment takes weeks.

The mechanics are where the recursive frontier is being probed. These systems optimize the loop itself, and are the ones to watch on the self-improvement question:

  • MARS (Google) runs a budget-aware tree search and tops the open-source MLE-Bench leaderboard.
  • Bilevel Autoresearch has an outer loop write and inject new search mechanisms into the inner loop at runtime.
  • NeoSigma (co-host) runs harness self-improvement in production, mining failures into a growing regression suite.

The pipeline systems exist because output outran trust. As generation got cheap, writing and review became the new work:

  • Writing-Driven Autoresearch, the ICML "Auto Research" hackathon winner, drafts the paper first and then forces every number to be backed by a real result or deleted.
  • PaperDoctor treats review as diagnosis: it locates weak claims and reruns the experiments behind them.

Verification is the bottleneck, not generation

The loop is only as good as the objective it optimizes against, and most failures are verifier failures.

  • Reward hacking. Optimize a score and the system games it; the Shopify overfit flag above is the mundane version. Standard defenses are a public/private split (optimize a visible score, decide survival on a held-out one) and a fixed cost budget, so wins are efficiency rather than brute force.
  • The evaluator is also the ceiling. Systems like AlphaEvolve only work where an automatic evaluator exists, which is why code and math have outrun everything that needs a human or a lab to grade it.
  • Reproducibility. A large share of AI results do not reproduce; alphaXiv reports around 70% and runs a reproduction agent (change arxiv to autoarxiv in any paper URL).
  • Review is gameable. Stop Automating Peer Review Without Rigorous Evaluation (ICML 2026) shows AI reviewers herd toward agreement and can be swayed by prose changes that leave the results untouched.

This is why the people who build benchmarks sit at the center of the field, not the periphery. SWE-bench — Kilian Lieret's work, and now downloaded over two million times — is exactly the kind of cheap, honest, verifiable metric that makes an autoresearch loop possible in the first place. A good verifier is worth more than a bigger model.

The boom reshaped the stack

When generation is cheap and the loop runs unattended for hours, the value moves to the parts that let you run and trust hundreds of experiments — the outer-loop layer earlier AGI House work flagged as the real product surface. Several parts of the stack got prominent fast, and specific players have moved on each:

  • Agent sandboxes. Isolated, reproducible execution is now load-bearing, because an agent editing and running arbitrary code overnight has to fail safely and repeatably. Teams reach for E2B, Modal, Daytona, and Microsandbox.
  • Coding-agent harnesses. The agent that reads, edits, and runs the code is the engine. Claude Code, Codex, Aider, OpenHands, and Pi (the one Lütke used) all serve here — and the minimal-harness camp, led by Lieret's mini-swe-agent, has shown a stripped-down 100-line agent can match or beat the heavyweights.
  • Verifiers, benchmarks, and environments. The scorer is the crux, so this is where quality is won or lost: SWE-bench and MLE-Bench as targets, tau-bench for agent reliability, and NVIDIA's NeMo RL and NeMo Gym, which shipped an explicit autoresearch workflow on the NeMo stack.
  • Experiment state and version control. Git is the accept-or-revert mechanism itself — every improvement is committed and every regression is thrown away, so the code only ever moves forward — paired with a running log of what has and has not worked (Karpathy's results.tsv, Lütke's autoresearch.jsonl).
  • Orchestration and memory. Long runs pass through context resets, so durable session memory and decision ledgers keep the objective and constraints intact across hours (NVIDIA's session-memory skill, the Ralphthon winner's decision ledger).
  • Cheap and parallel compute. Single-GPU minimalism plus on-demand and parallel execution turns a grid of experiments into an overnight wall-clock win; the Vector Institute's SkyPilot port ran 910 experiments across 16 GPUs in eight hours.

Weights & Biases (tracing via Weave) and NVIDIA (NeMo, Brev) both sponsored and built into this year's autoresearch events, which is a fair signal of where the infrastructure money thinks this is going.

Three tracks, three ways to contribute

Any autoresearch project is either improving the machinery, aiming it at a problem, or making its output believable. Full descriptions are on the event page.

  • Track 1 — Build the loop. The engine: search, harness optimization, self-improvement.
  • Track 2 — Run the loop. Point it at a real problem, whole or by stage: discovery, paper-to-code, writing.
  • Track 3 — Trust the loop. Verification: evaluation, reproduction, reward-hacking, review.

Build-day projects

Each is scoped to a day and built around a clean, fast, hard-to-game verifier. Stacks are starting points.

Track 1 — Build the loop

  • Karpathy loop, new domain. Take the keep-or-revert loop and point it at a verifiable task outside ML training — routing, packing, GPU-kernel throughput, or a slow function in your own codebase. The deliverable is a working loop plus a log of improvements that survived a held-out check. Stack: karpathy/autoresearch as scaffold, a coding agent, a fixed-budget scorer.
  • Harness optimizer. Instead of optimizing a solution, hill-climb the agent's own scaffold — its prompts, retrieval, and tool routing — over a small family of tasks, then measure whether the discovered harness transfers to tasks it never saw. Stack: DSPy, a small benchmark subset.
  • Mechanism injection. Build a two-level loop where the outer loop reads the inner loop's code, spots where the search is stuck, and writes a new search strategy (a bandit, tabu search, evolutionary population) that it validates before switching on. Stack: the Bilevel Autoresearch repo as reference, an import-and-revert guard.
  • Search-strategy bake-off. Hold the task fixed and swap the greedy accept-or-reject rule for tree search, a bandit over competing lineages, and evolutionary search; report which wins under an identical compute budget. Stack: nanoGPT as the task, an in-memory database of past attempts.

Track 2 — Run the loop

  • Paper-to-code agent. Give an agent a recent arXiv paper and have it form a plan, implement the method, write tests, and launch a short validation run, with a human reviewing the plan before compute is spent. Stack: a coding agent, NeMo RL and NeMo Gym or plain PyTorch, nanoGPT-scale models.
  • End-to-end mini AI-scientist. Carry a single small question from hypothesis to experiment to a short write-up, with a novelty check against the literature so the result is not something already known. Scope it tightly and verify aggressively. Stack: multiple agent personas, the arXiv API, LaTeX.
  • Writing-driven loop. Draft a paper as a write-ahead log in which every number starts as a placeholder that a verification script must either back with a real measurement or strip out before the build passes. Stack: LaTeX macros plus a verify script, using the Ralphthon repo as a template.
  • Discovery micro-loop. Run a closed loop on an objective with an exact grader: symbolic regression on a dataset, or a FunSearch-style search for a better combinatorial construction, seeded optionally with a human idea to measure the lift. Stack: PySR or a coding agent, an exact evaluator, an in-memory solution database.

Track 3 — Trust the loop

  • Reproduction agent. Point an agent at one claim from a recent paper and have it rebuild a minimal version, estimate the cost of full replication, and return a verdict on where the claim holds and where it breaks. Stack: alphaXiv autoarxiv as reference, a sandbox, the paper's repo.
  • Reward-hacking probe. Build an evaluation with a public score and a hidden held-out score, then set an adversarial agent loose on the public score and measure how far the two diverge. The gap is the finding. Stack: any task with a held-out scorer, a second agent as the adversary.
  • Paper diagnostician. Produce feedback on a draft as concrete triples — an observation, the exact location, and a suggested fix — and rerun the experiments behind the highest-priority claims within a compute budget. Stack: a coding agent, PDF and code parsing, a sandbox such as E2B or Daytona.
  • Living regression harness. Run an agent on a task suite, mine and cluster its failures, promote each fixed failure into a growing regression suite, and gate every future change against it. Show that gains compound as the suite tightens. Stack: tau-bench, a clustering step, a tracing tool.
  • Review-robustness tester. Measure how much an AI reviewer's score moves when a paper's prose is rewritten but its results are left unchanged — a direct test of the "paper laundering" failure. Stack: a judge model as the reviewer, a rewrite agent, a small set of papers.

Why AGI House

Autoresearch advances by people building loops — and, more, by people building the verifiers that make loops worth trusting. AGI House has been convening this community as it forms; prior build days on self-evolving agents drew well over a hundred builders around these ideas. This event puts three people defining the field in the room and hands you a track.

Further reading

See you in Hillsborough on Saturday.

‍