Recursive Self-Improvement
Agents can already edit their tools, skills, and harness. Recursive self-improvement still needs a system that can raise the verifier without capturing it.
📝 摘要
Philipp Schmid 系统梳理了 AI 智能体递归自我改进（Recursive Self-Improvement, RSI）的三个层次：迭代（输出改进、系统不变）→ 自我改进（系统持久变化，如增加工具/技能，但评估标准不变）→ 递归自我改进（系统同时提升评估标准本身，且不捕获/操控评估信号）。当前所有公开系统仅达到第二层——agent 可以编辑 prompt、skill、tool、harness 代码，但无法重新定义成功标准。文章指出验证独立性是 RSI 的核心瓶颈：一旦 agent 能编辑评估器，分数就不再是证据；而品味（Taste）——判断什么算赢——仍需人类在环。近期的 autoresearch（Karpathy）、Prime Intellect、Cline hill climbing、AlphaEvolve 等实验展示了有界自我改进的可行性，模型–harness 协同进化是最不玄学的描述。Pi 和 DeepSeek Harness 代表了 agent 可写 harness 的两种极端（4 个内置工具 vs. 一切皆插件）。
核心概念： 递归自我改进要求系统在提升自身能力的同时提升验证标准，且不能捕获验证信号——当前没有任何公开系统能做到这一点，验证独立性和品味仍是人类的责任。
关键技术栈 / 关键要点：
- 三层改进模型 — Iteration（改输出）→ Self-improvement（改系统）→ RSI（改验证器），绿色标记决定哪一层可被循环移动
- 模型–harness 协同进化 — harness 改进产生更好的 traces 用于训练下一代模型，模型再生成更好的 harness 编辑，形成双循环
- Autoresearch 循环 — Propose→Train→Eval→Keep/Revert，~700 实验约 20 个迁移，nanochat 时间从 2.02h 降至 1.80h
- AlphaEvolve — 同样的 keep-or-revert 循环应用于算法发现，将 4×4 复矩阵乘法从 49 降至 48 次标量乘法
- Agent 可写 harness — Pi 仅 4 个内置工具+TypeScript 扩展自动发现；DeepSeek Harness 基于 Cordis 插件内核，模型/沙箱/控制循环皆可替换
- 验证瓶颈 — 当前 agent 与评估器必须分离（人类持有 held-out tasks 和 hidden score），否则 reward hacking 是默认行为
- 测量缺口 — 现有基准（HarnessOpt-Bench/PAST-Bench）只测任务分数提升，RSI 需要额外测量：下一轮是否面对更难但仍然诚实的标准
关键结论 / 实践建议： 递归自我改进不需要更好的模型——一个冻结模型配合诚实验证器和可写环境就能自行攀登。但递归部分缺失的关键是：如何在不捕获评估信号的前提下提升验证器。在解决此问题之前，我们做的是自我改进，不是递归。
Earlier this week I tweeted:
The next iterations of agent harnesses will center on coded extensions that integrate automatically. Pi lead, others are following, and DeepSeek represents the extreme.
All powered and driven by autoresearch and recursive self-improvements.
For most of AI's history, recursive self-improvement belonged to theory and science fiction. I. J. Good described an "intelligence explosion" in 1965: a machine designs a better machine, which becomes better at designing the next one. The curve goes vertical.
We are surprisingly close to a narrow version of that loop. Agents can inspect failed runs, edit their tools and instructions, test the result, and keep what works. They are also beginning to run experiments that produce better models. The results are scrappy, but the pieces are starting to connect.
What is recursive self-improvement?
Retrying a failed task is easy to mistake for learning. I use the following definition:
Recursive self-improvement is a loop in which a system makes a persistent change that improves its future performance and its ability to produce subsequent improvements.
What a run leaves behind
Iteration
Edit code, rerun the test.
Outputchanges
Systemfixed
Verifierfixed
The next task starts from the same agent.
Self-improvement
Add a tool, record a skill.
Outputchanges
Systemchanges
Verifierfixed
Future tasks run through a different system.
Recursive self-improvement
Raise the bar itself.
Outputchanges
Systemchanges
Verifierrises
Later rounds face a harder, still-honest test.
Each loop is defined by which layer persists after the run — and green marks what the loop is allowed to move.
Iteration improves an output while the system stays the same. An agent edits code, reruns a test, and the next task still starts with the same agent.
Self-improvement changes the system persistently. The agent adds a tool, records a skill, or changes how it compacts long conversations. Future tasks run through a different system. The ruler that says "better" does not move.
Recursive self-improvement also raises that ruler. The system gets better at judging, not only at scoring. Later rounds face a harder test that is still independent of the agent.
Current systems work best when an external evaluator stays fixed. A test passes, validation loss drops, or a benchmark score rises. The system can search because it has a ruler it doesn't control. A recent survey shows that agents can edit a prompt, tool, skill, or piece of harness code, but they can't redefine success.
Open-ended recursive self-improvement asks for more. The system would improve how it finds changes and how those changes are judged. It would strengthen the verifier without being able to game it. Public evidence for that remains thin.
A higher task score shows improvement. Recursion needs another measurement: did the next round face a harder bar that the system still could not cheat?
The missing half of the loop
Today: bounded
Agent can edit
EditTestKeep
Evaluator
fixed · outside the loop
The agent can search because it is scored by a ruler it doesn't control.
Missing: raise the bar
Agent can edit
EditTestKeep
raises the bar
Harder tests
stricter · still not gameable
The system strengthens the evaluator, and later rounds are judged against a signal it still cannot capture.
Self-improving models
Models have long improved through their own outputs, self-play, student-teacher training, or successful reasoning traces. Later work lets a model score its own training preferences or propose synthetic data and update directives. But researchers still set the objective, the update rule, and the tests. The model's output feeds the loop. The loop itself stays fixed.
Agents are now improving the code around that loop. Karpathy's autoresearch is the simple version. An agent propose a change, trains for a few minutes, keep it only if validation loss drops. On nanochat it ran about 700 experiments, found about 20 that transferred, and cut time-to-GPT-2 quality from 2.02 to 1.80 hours. Prime Intellect scaled the same loop to 10,000 trials and beat the human baseline.
Autoresearch
~700
experiments, one GPU (nanochat)
~20
changes kept and transferred
2.02 → 1.80 h
time to GPT-2 quality
Prime Intellect scaled the same keep-or-revert loop to ~10,000 trials on H200s and beat the human baseline.
AlphaEvolve is the same idea aimed at algorithms. It mutates programs, scores them against an automatic evaluator, and keeps the winners. It found a way to multiply 4×4 complex matrices in 48 scalar multiplications, one fewer than Strassen's 49, and sped up a kernel used to train Gemini by 23%. A model improving the code that trains the model is the recursive loop in a single sentence.
Newer experiments connect both. SIA updates both a task agent's harness and its weights. Recursive Harness Self-Improvement edits a harness partly to produce better traces for training future models, and calls the result model–harness co-evolution.
Model–harness co-evolution
Recursive self-improvement doesn't require a better model. A frozen model with an honest verifier and a writable environment can climb on its own. The easier target is the harness around it.
Agents editing their own harness
The idea is simple. Run a baseline, inspect the failures, change one part, and test again. Cline was able to hill climb Opus 4.5 from 47% to 57% in Terminal Bench manually and a few months later, an agent ran the same method for 17 hours and about $50 of compute. It moved Kimi K3 from 69 of 89 tasks to 79, with better retries, loop detection, and process handling.
Those improvements fall under bounded self-improvement. The agent changed its environment and kept the changes. The report does not show whether the updated system became better at finding its next change.
HarnessOpt-Bench asks whether such gains survive a stronger test. An agent edits its harness on development feedback; a separate system tests the candidate on hidden tasks. Across 111 runs, 5 optimizer models, and 4 tasks, results varied sharply by model and task. The benchmark measures whether an edit improves scores. RSI needs a second measure: whether later rounds face a harder bar the system still cannot cheat.
Measurement gap
What we measure
Task score, rising over rounds.
What recursion requires
Does the next round face a harder, still-honest bar?
A rising score proves self-improvement. Recursion is a claim about the other curve.
PAST-Bench asks whether stored experience actually helps later episodes. In many of its scenarios, turning memory on does not. A new RSI Benchmark proposes measuring AI systems doing AI research, which should show whether each round makes the next round faster or better.
So what should we count as recursion? Hyperagents comes close. The system can change an agent as well as the code that creates new agents, and improvements like better memory storage helped across later runs and tasks, but these are still bounded loops. The fitness function stayed outside the editable code.
Archive-based search
Fitness function
Outside the tree. Every variant is scored by code no agent can edit.
Greedy selection would have pruned the 58. The archive kept it — and it parented the best agent.
The agent takes control of its own setup
Early agents were a system prompt plus a handful of tools. We then added memory, compaction, hooks, skills, and control flow. Each addition made the harness more important and harder to change.
The next harness change will not be a bigger prompt. It is code the model can write, and that the runtime can load without a human rewriting the core. The harness will pick up the change without human intervention.
Pi was first. It ships 4 tools (read, write, edit, bash) and a system prompt under 1,000 tokens. Everything else is a TypeScript extension, auto-discovered from .pi/extensions/. An agent can write one, reload it, and continue with new tools. Others are following. Amp stores project plugins with the codebase.
DeepSeek is the extreme. DeepSeek Harness is built on the Cordis plugin kernel and treats almost every part as replaceable: models, tools, sessions, sandboxes, and the control loop itself. Plugin side effects unwind on unload, so the runtime can swap parts of itself without dying. Their shorthand is Agent = Model + Harness. An agent gets more code it can improve, and more ways to break compatibility or weaken a permission boundary.
Who can rewrite the harness
Fixed coreEverything is a plugin
Conservative
Claude Code · Codex · Cursor
Skills, hooks, and plugins extend a fixed core.
Pi
read · write · edit · bash
Four built-in tools; everything else is an extension the agent can write and reload.
DeepSeek
deepseek-harness
Models, sandboxes, and the control loop itself are swappable plugins.
The green meter marks how much of the harness the agent can rewrite.
That shift matters for two reasons. The agent can build capabilities its developers didn't predict. And code can run a sequence of operations without filling the context window with every intermediate result. The same properties make failures persistent.
The recursive part is still missing
An agent can overfit visible tasks, exploit bugs in the tests, or change a test so broken code passes. If it can edit evaluation, it can jailbreak itself. Reward hacking is the default behavior of a system asked to raise a number.
The agent and the system that verifies it have to stay apart for the moment. The agent may change prompts, skills, tools, memory, and harness code. A separate entity needs to own the evaluation. That's why are not at recursive self-improvement.
Recursive self-improvement needs the system to improve the verifier as well, harder tests, better judges, a higher bar. And it needs to do that without capturing the signal. Today the system does not know how to keep the verifier. Humans still set the objective and hide the real score.
Who owns the ruler
Today: kept apart
Agent owns
promptsskillstoolsmemoryharness code
Humans own
held-out taskshidden score
If the agent can edit the evaluator, the score stops being evidence.
What RSI needs
Agentraises the barVerifier · still hidden
The system strengthens the verifier without capturing it. No public system does this yet.
A Princeton-led study found that today's agents can execute much of the engineering of AI research while still struggling to choose original and useful directions. The loop is excellent at hill-climbing a verifiable metric. Taste is not a metric. Raising the bar without taste is a faster way to optimize the wrong thing.
These loops already deliver real things, faster training code, better tools, agents that fix their own retry logic overnight. What is still missing is the recursive part. Until the improver can raise the bar and still fail it, we are doing self-improvement. Not recursion.
Three opinions loosely held
The near future is local recursion. Not a system redesigning its architecture in the dark. Agents writing the extensions the next session treats as native, and trajectories are used for training when they are good enough. Model–harness co-evolution is the least mystical description of where this is going. It is also the one the evidence supports.
Verification is the bottleneck. Every convincing result has a ruler the system does not own. The moment the system owns the ruler, it will get very good at looking improved. Bigger models will not fix that. A system that knows how to raise the bar, and keep it honest, might.
Taste still lives outside the loop. Agents will raise any number you give them. Recursive self-improvement without taste is a faster way to optimize the wrong thing. Deciding what counts as a win and that reward hacking does not is still our job.
Thanks for reading!