← Back to blog

Designing agents for recursive self-improvement

2026-08-29

When we design a coding agent, the eventual goal is not just "it writes good code." The goal we are aiming at is recursive self-improvement (RSI): a loop that recursively improves software with the human out of the critical path — it identifies a weakness, implements a change, verifies the result, keeps what helps, and repeats, choosing its own goals and checking its own work.

This post lays out that goal, explains why today's state-of-the-art agents still keep a human at both ends of the loop, and argues that closing that gap takes progress on two fronts: better models and a better harness.

What we mean by RSI

In the frontier framing, RSI is a system that improves its own successor. Anthropic calls it "when AI builds itself"; Sakana's Darwin Gödel Machine rewrites its own code and climbs SWE-bench from 20% to 50%; DeepMind's AlphaEvolve evolves code with an automated evaluator.

For a coding-agent product, the practical version is: the user's project gets recursively better, on its own. The agent proposes what to improve, does the work, and verifies the result — the human is no longer the bottleneck at either end. This is not the model training its own weights. It is the agent's own harness — its prompts, its agent specifications, its flows — that is defined, created, and continuously modified and improved by the LLM itself, in an autonomous loop. The user's codebase and configuration are refined as part of the same loop.

Current SOTA: the human-in-the-loop, and why it is stuck there

The best agents today are strong at execution. In Anthropic's framing they are "autonomous agents" that run code themselves and delegate hours of work to other agents. On METR's task-completion measure, capable models handle tasks that would take a human expert roughly twelve hours; SWE-bench (real bug reports on real open-source repos) has been saturated; research-reproduction benchmarks like CORE-Bench followed. The doing now costs almost no human time — only compute.

And yet the loop that actually ships is:

human proposes a goal → agent works → human reviews the result

This is the state of the art precisely because of two remaining limits:

  1. The agent cannot yet choose the correct goal. It does not reliably know what is worth building, so a human must propose or select the goal. Direction is human labor because the agent's judgment about what to pursue is not yet trustworthy.
  2. Generation is not perfectly correct. The agent's output still needs verification, so a human must review the code — and as generation outpaces human reading speed, code review has become the bottleneck. Review is human labor because the agent's output is not yet self-certifying.

So the human sits at both ends not by design but by necessity. The loop cannot close on its own. (A caveat worth keeping: METR's "time horizon" is a human-duration proxy for task difficulty, not a measure of how long the model runs on its own — the "12-hour tasks" phrasing easily misleads. The capability trend is real; the framing needs care.)

The gap: RSI removes the human from both ends

Seen this way, the gap between current SOTA and RSI is exactly those two ends. RSI is reached when the cap closes — when the loop no longer needs a human to choose the goal or to review the result. The agent must (a) determine the right goal to pursue, and (b) verify its own work well enough that human review stops being the limiter. Closing those two ends is the whole game.

How we get there: model and harness both matter

Achieving RSI is not a harness-only story. Two things have to improve, and they compound:

  • The model. Better models attack both ends directly. A model that can determine the correct goal gives the loop reliable direction; a model strong enough at verification can review its own code. Model progress is a genuine contributor to RSI — as models get better at judgment and at checking work, the human can step back. We should not pretend harness alone closes the gap.
  • The harness. Equally, the harness we design matters. Even with today's models, the right orchestration and evaluation structure pushes the loop toward autonomy: agents and flows defined by the LLM, an automated reviewer that screens candidates so review is no longer a human bottleneck, goal-selection mechanisms that surface and rank candidate improvements, and an eval-steered loop. The harness is the part we build; it compounds with model progress.

Pretending it is one or the other is the mistake. RSI arrives when a better model meets a harness built to use it.

Our design idea: a harness that drives toward human-out-of-loop RSI

The central design bet is this: do not hard-code the agent's capabilities. Let the LLM define new agents and new flows at runtime from a goal.

Orchestration primitives

The building blocks are established. An agent can hand off control to a specialist, or call another agent as a tool (a manager stays in control and invokes a specialist as a bounded capability). OpenAI's Agents SDK, Anthropic's managed-agent roster, and LangGraph's supervisor all converge on these two patterns.

LLM-created agents

Given a goal, the model authors a specialist agent — its instructions, its tools, its handoffs — as a specification it can load and run. Research already demonstrates this: AutoAgent generates whole agents and workflows from natural language; SwarmAgentic evolves populations of agent systems, refining both functionality and coordination.

LLM-created flows

The model can also author the orchestration itself — a graph of steps (sequence, parallel, handoff, loop) — and invoke it as a single tool call, exactly like an agent. The flow becomes a first-class, reusable, evaluable unit.

Why this extends execution

A complex task is no longer one monolithic loop. It is decomposed into specialist agents coordinated by a generated flow, so the agent takes on longer, more entangled work than any single completion could.

Closing the two ends via harness

This is where the harness earns its place alongside the model:

  • Direction without a human. Goal-selection mechanisms mine telemetry and past failures to surface and rank candidate improvements; the agent proposes the goal itself. The model's improving judgment does the choosing; the harness provides the mechanism and the evaluation that ranks options. As models improve, the human's role shrinks to oversight.
  • Review without a human. An automated critic/review agent verifies each candidate against project-derived evaluation and acts as a fast, scored, pre-merge gate. Better models make this reviewer trustworthy; the harness makes it the default path so review stops being a human bottleneck.

What the next-generation agent looks like

Pulling it together, the agent that delivers RSI looks like this:

  • Its capabilities are not fixed — agents and flows are defined by the LLM at runtime from a goal.
  • It decomposes complex work into specialist agents coordinated by a generated flow.
  • It chooses its own goals and verifies its own output, tending toward no human in the critical path — because both the model (judgment, review) and the harness (selection mechanisms, automated reviewer) have improved.
  • Its loop is driven by evaluation, so each turn compounds instead of drifting.

References