Opinion

How Close Is Recursive Self-Improvement? Two Researchers Disagree

Dwarkesh put former METR researcher John Beren and researcher Charlie in a room to argue about recursive self-improvement (RSi). The 64-point, 53-comment HN thread revealed a wider gap than expected, and both sides managed to dodge the actual middle ground.

Font size

Dwarkesh's latest podcast put two researchers with opposing views at the same table: former METR researcher John Beren and researcher Charlie, debating recursive self-improvement (RSi).

On Hacker News, the episode pulled in 64 points and 53 comments—modest numbers, but the comment quality ran higher than the score suggests. Beren comes from METR, the organization known for capability evaluations and "real-world task duration" benchmarks on frontier models, giving him first-hand data on what AI can actually do. Charlie's optimism draws from a different well.

The two sides aren't arguing about the same thing. That's the easiest point in the whole debate to misread.

What This Debate Is Actually About

Three core questions:

  1. Can AI keep making itself stronger with minimal human engineer involvement?
  2. If so, does the curve rise smoothly or jump in sudden leaps?
  3. How many years out are we from "AI writing the next generation of AI"?

Beren and Charlie diverge most on questions 2 and 3. Looking at evaluation benchmarks, Beren sees the failure modes of current systems on real long-horizon tasks as remarkably stable—the same categories of mistakes recur, and what gets called "self-improvement" is closer to single-point optimization than system-level leaps. Charlie prefers to extrapolate from compute curves and recent model progress on coding and research-assistance tasks, arguing that automated research engineering (AE) is already near a tipping point.

Beren's Case for Pessimism

Beren has watched too many agents stumble on "real tasks" during his time at METR. The organization's HCAST benchmark (real software engineering tasks) shows frontier models completing many 1–2 hour tasks at under 50% success rates. The failure modes aren't "almost there"—they're distinctly engineering-flavored:

  • Once the context window fills up, the model starts forgetting, looping, and going in circles
  • Tool calls look correct but execute with subtly wrong semantics
  • One bad step in a complex task cascades into total collapse, with no self-correction

From an evaluator's perspective, this means model self-correction isn't scaling alongside capability. The GPT-4 → GPT-5 jump was real, but the growth curve looks more like coverage expansion than per-task error reduction.

Beren's implicit argument: recursive self-improvement requires at least a stable closed-loop error-correction mechanism. Current models lack that loop. They're more like very capable interns who need supervision.

Where Charlie Pushes Back

Charlie's optimism rests on a different foundation:

  • Compute curves are still climbing exponentially, and inference-side costs are dropping faster than training-side costs
  • Recent models show clear gains on coding benchmarks like SWE-bench Verified and Terminal-Bench
  • Automated research engineering can already handle literature reviews, ML code modifications, and small-scale experiments

Charlie's core claim: RSi doesn't need AGI-level capability. It only needs a model that can reliably run the "write code → run experiment → read result → modify code" loop. In narrow domains (ML paper reproduction, specific algorithmic optimizations), that loop is already kind of working.

His framing: you're setting the bar too high. RSi doesn't require a model that contemplates existence. It just needs a model that iterates inside an environment with a clear reward signal.

The Middle Ground Everyone Ignores

The real fight is over definitions. Beren is thinking "AI gets stronger without human engineers in the loop." Charlie is thinking "AI already completes end-to-end improvement cycles in specific domains." These aren't the same question.

A few examples of the middle ground already in production:

  • AlphaEvolve (the DeepMind one): for narrow tasks like algorithm discovery, a model plus evolutionary search already produces results that beat human designs. Is that RSi? If so, it's already happened.
  • AutoML pipelines: tools like AutoGluon and FLAML are, in some sense, "machines picking models and tuning hyperparameters themselves." They don't need LLMs, but they're proto-RSi.
  • Code agents writing their own tests: tools like Devin and Cursor can handle "write code → run tests → read failure → patch code" in some workflows, though each step still has human oversight behind it.

My read: RSi isn't a 0/1 switch—it's a gradient. We've achieved partial RSi in narrow scenarios; nobody wants to call it that because naming it would imply AGI is right around the corner.

A Few Comments Worth Pulling Out

The HN comments disagreed less than the podcast participants, but a few angles are worth noting:

  • One high-upvoted comment noted: RLHF/RL training environments might themselves be proto-RSi—the reward model is human-defined, but policy optimization runs autonomously. If "humans providing the reward signal" counts as external input, then RLHF is already semi-automated research engineering.
  • Another took an information-theoretic angle: the bottleneck for recursive self-improvement isn't intelligence, it's information channels. The data a model can read about its own behavior (traces, logs, rewards) is limited, and improvement speed gets capped by that channel.
  • Others pointed out that RSi and "AI accelerating AI research" are two different things. The former is a model modifying its own weights; the latter is a model helping human researchers build better models faster. The latter is already happening (many ML papers' experimental sections are AI-assisted), the former has no footprint yet.

Podcast link: https://www.dwarkesh.com/p/john-beren-charlie

Editorial Take

For practitioners in 2026, the useful part of this debate is realizing that the RSi timeline isn't a prediction problem—it's an engineering problem.

The right question isn't "will AI recursively self-improve" but "at which layer does it happen, and who triggers it." Break it down:

  • Layer: weight-level (directly modifying its own parameters), code-level (modifying the code that implements it), or environment-level (modifying the reward that trains it)? Each layer has a different bottleneck.
  • Trigger: human researchers, AI agents, or a closed-loop pipeline? Beren and Charlie each assume a different trigger, which is why they never land on the same conclusion.
  • Evaluation: what metric counts as "improvement"? SWE-bench? Internal benchmarks? Real-user studies? Different metrics yield opposite conclusions.

A contrarian read: most RSi arguments are arguments about definitions, not facts. Next time you see "X says AI will self-improve in three years, Y says ten," ask which layer they're arguing about first.

What I'm unsure about: whether the middle ground (AlphaEvolve-style systems) counts as "real" recursive self-improvement. There's no accepted definition. If DeepMind's next release labels AlphaEvolve as "first practical recursive self-improvement," the entire discourse reshuffles overnight. That call I can't make.

Source: https://www.dwarkesh.com/p/john-beren-charlie