Recursive self-improvement (RSI) is a feedback loop in which an AI system uses its current intelligence to improve the cognitive machinery that produces its intelligence, potentially leading to rapid, open-ended capability gains. Originating with I. J. Good’s 1965 concept of an “ultraintelligent machine” — a machine that surpasses humans in all intellectual activities and designs successively more intelligent machines — the term was formally used by Yudkowsky (2008) to describe a specific loop: an AI that improves itself by rewriting its own code or weights. In modern practice, RSI may involve the model directly rewriting its weights, but more commonly it improves the training pipeline, deployment system, and harness (the software layer that orchestrates execution). Much contemporary work on auto-research, self-improving agents, and evolutionary program search can be organized around this question. Harness engineering — the design of the system that controls how the model observes, acts, memorizes, checks itself, and improves — is a key near-term path to RSI, as improvements to the harness can be reused across many tasks and recursively improved by the model itself.
Key Points
RSI originates from I. J. Good (1965) “ultraintelligent machine” and Yudkowsky (2008).
A harness is the surrounding system that orchestrates a base model: workflow design, evaluation, permission controls, persistent state.
Harness design patterns include workflow automation, file system as persistent memory, and sub‑agent/backend job management.
Meta‑Context Engineering (MCE) treats context management as a learnable skill with bi‑level optimization.
Meta‑Harness and Self‑Harness evolve the harness code itself using LLM‑based loops.
Evolutionary search approaches (Promptbreeder, GEPA, AlphaEvolve, Darwin Gödel Machine, etc.) optimize prompts, programs, or workflows through mutation and selection.
Six major bottlenecks remain: weak/fuzzy evaluators, context/memory lifecycle, negative results, diversity collapse, reward hacking, and long‑term success.
Human oversight remains critical; systems should move humans up the stack, not remove them.
Benchmarks such as PaperBench, CORE‑Bench, RE‑Bench, MLE‑bench, KernelBench, and ScienceAgentBench evaluate agent performance in research‑engineering tasks.
Concepts
Ultraintelligent Machine (Good 1965): A machine that can surpass all human intellectual activities and design even smarter machines, leading to an “intelligence explosion.”
Harness: The software system surrounding a base model that orchestrates execution, decides how the model thinks and plans, calls tools, perceives and manages context, stores artifacts, and evaluates results. Includes workflow design, loop engineering, evaluation, permission controls, and persistent state management.
Harness Engineering: The process of designing and improving the harness. In the context of RSI, the harness becomes an optimization target that can be recursively improved by the model itself.
Meta‑Context Engineering (MCE) (Ye et al. 2026): A framework that separates the mechanism of managing context (skill) from the artifact content. Bi‑level optimization: inner loop finds the best context for a given skill; outer loop evolves the skill itself.
Meta‑Harness (Lee et al. 2026): An outer‑loop algorithm that optimizes the code determining what information is stored, retrieved, and presented to the model — a harness for optimizing harnesses.
Self‑Harness (Zhang et al. 2026): A propose–evaluate–accept loop where LLM agents improve their own harness by mining failure patterns, proposing edits, and validating them.
Evolutionary Search: Optimization method inspired by natural selection, evolving a population of solutions through mutation and fitness selection. Used in RSI contexts to evolve prompts, programs, or workflows (e.g., Promptbreeder, GEPA, AlphaEvolve, Darwin Gödel Machine).
Reward Hacking: A risk in self‑improvement loops where the system overfits to proxy signals (unit tests, judge model preferences, benchmark artifacts) rather than true objective.
Details
Harness Design Patterns
Modern harness engineering moves beyond early “LLM + memory + tools + planning” frameworks. It incorporates four key patterns:
Workflow Automation: A goal‑oriented loop — plan, execute, observe/test, improve, repeat until goal achieved. Example: Karpathy’s autoresearch repo. The Codex agent loop uses tool calls whose responses affect the next generation. The workflow graph emphasizes analyzing trajectories and failure cases through an “agent runtime” rather than a static prompt.
File System as Persistent Memory: Instead of carrying the entire workflow and logs in context, the harness stores durable state in files (experiment logs, code diffs, error traces, rollout trajectories). These artifacts often exceed context windows. Learning to read/write/edit the file system (via bash commands) is a foundation skill that benefits from core model improvements.
Sub‑agent and Backend Jobs: A harness can spawn multiple sub‑agents for parallel hypotheses or concurrent experiments. The parent agent uses a small process manager to launch jobs, inspect logs, cancel failures, and merge results. Outputs stored as files allow recovery from interruptions and reasoning over execution history.
Core Interface of Coding Agents: Stabilized around a common tool loop with groups: file system (glob, grep, read, write, edit, patch), shell execution (bash), IO (LSP, git tools), external context (MCP tools, Skills), web search, artifacts, backend processes (Cron), and agent delegation (spawn, resume, wait, close, interrupt).
Context Engineering
Agentic Context Engineering (ACE) (Zhang et al. 2025): Treats context as an evolving playbook of bullet points, each with identifier and description. Three components: Generator (produces trajectories referencing bullet points), Reflector (distills insights from successes/failures), Curator (updates context with structured items, merging and deduplicating periodically).
Meta Context Engineering (MCE) (Ye et al. 2026): Formalizes context management as a skill ( s \in \mathcal{S} ) defining a context function ( c_s = (\rho_s, F_s) ) where (\rho_s) are static components (prompts, knowledge bases, code libraries) and (F_s) are dynamic operators (search, selection, filtering, formatting). Bi‑level optimization:
Skills and context are instantiated as a directory of files (static skill.md and dynamic contexts). Both levels execute in agentic coding environments with tools {Read, Write, Edit, Bash, Glob, Grep, TodoWrite}.
Meta‑Harness and Self‑Harness
Meta‑Harness (Lee et al. 2026): Outer-loop optimization over the harness code. A coding agent proposes harness candidates; the output is a Pareto frontier of harnesses. Execution history is accessible via file system (grep, cat). A proposed harness is a dictionary containing its source code, scores, rollout trajectories, and state updates. The loop iteratively creates new harnesses, keeping qualified ones. Demonstrated on text classification and TerminalBench‑2.
Self‑Harness (Zhang et al. 2026): A propose–evaluate–accept loop with three stages:
Weakness mining: Cluster failures into verifier‑grounded failure patterns from execution traces.
Harness proposal: Propose bounded edits based on mined patterns, using editable surfaces, verifier‑grounded failures, passing behaviors, and earlier edits.
Proposal validation: Evaluate the edit and accept if it improves performance.
Security concerns arise when a program can edit the OS — abstraction boundaries must be protected. Permission control and security layers must live outside the loop.
Evolutionary Search Approaches
Promptbreeder (Fernando et al. 2023): Optimizes task‑specific prompts via mutations; the mutation prompts themselves evolve.
GEPA (Agrawal et al. 2025): Combines reflection‑based prompting with evolutionary search, using natural language reflection over trial‑and‑error to propose prompt updates.
AlphaEvolve (Novikov et al. 2025): Stores programs and prompts; uses frozen LLMs to generate diffs for improvement. Code regions marked with # EVOLVE-BLOCK-START/# EVOLVE-BLOCK-END. Meta‑prompt co‑evolves. Ablations show value of evolution procedure, context in prompts, and meta‑prompts.
ThetaEvolve (Wang et al. 2025): Combines evolutionary search with RL and in‑context learning.
ShinkaEvolve (Lange et al. 2025): Improves LLM sampling efficiency via parent sampling (balancing performance rank and offspring count), code‑novelty rejection sampling (discarding too‑similar candidates based on embedding cosine similarity), and meta‑scratchpad (identifying good patterns in successful solutions).
Darwin Gödel Machine (DGM) (Zhang et al. 2025): Evolves an editable harness‑code repository. Starts with one coding agent. Each iteration picks a parent (probability proportional to performance, inversely to child count) to modify its harness code via bash and editor tools. Only agents with sufficiently high performance join the pool. With Claude 3.5 Sonnet, DGM‑discovered agents achieved on SWE‑bench Verified 20%→50% and on Polyglot 14.2%→30.7%. Works best with auto‑evaluable fitness (e.g., matrix multiplication, algorithm contests, datacenter scheduling).
SIA (Hebbar et al. 2026): Early attempt to combine harness improvement and model‑parameter updates. Meta‑Agent proposes harness; Task‑Specific Agent executes; Feedback‑Agent decides whether to update harness or model weights. Confounding choices (weaker task‑specific model, weak baselines) leave provisional evidence.
AI Scientist and Auto‑Research
AI Scientist (Lu et al. 2026): Expert‑designed pipeline for proposing ideas, writing code, running experiments, analyzing results, writing manuscripts, and performing peer review. Note: paper production ≠ scientific discovery — fabricated citations and weak results are possible.
ScientistOne (Meng et al. 2026): Makes verifiability a central constraint — every claim traces to an evidence source, audited by Chain‑of‑Evidence checks.
Autodata agent (Kulikov et al. 2026): Synthesizes training/evaluation data at the “just right” difficulty level using a challenger (proposes problems), weak solver, strong solver, and verifier. Limitation: tasks fine‑tune only weak solvers; loop acts as indirect distillation.
Automated Design of Agentic Systems (ADAS) (Hu et al. 2025): Meta‑agent programs new agents entirely in code, starting from an archive of simple workflows, generating high‑level description then code, self‑refining for novelty, evaluating, and adding successful candidates.
AFlow (Zhang et al. 2025): Represents agentic workflow as a graph (LLM‑invoking nodes, logical edges). Optimizes via MCTS: start from a template, select node using soft mixture of score and exploration, expand by asking LLM to modify workflow conditioned on evaluation performance, execute, evaluate, add to tree if improved. Experiments on QA, code, and math show improvements over manually designed workflows and ADAS.
Self‑Taught Optimizer (STOP) (Zelikman et al. 2023): Seed improver (I_0) takes solution (s), utility (u), and model (M), returns improved (s'). Goal: improve the improver (I) itself via meta‑utility (\hat{u}(I)). Experiments with GPT‑4 discovered strategies (genetic algorithms, simulated annealing, beam/search). Degraded with weaker models (GPT‑3.5, Mixtral) – base model capability is essential.
Six Bottlenecks Toward Full RSI
Weak and fuzzy evaluators: Many research claims lack fast, precise verifiers. Self‑improvement works best with measurable, objective metrics. Research taste, novelty, long‑term value are hard to quantify.
Context and memory lifecycle: Autonomous agents need harness‑managed context and memory to complement long‑context limitations. Context engineering must become a core part of intelligence.
Negative results: Literature bias toward successes; LLMs may be bad at abandoning hypotheses or reporting failures. A research harness should preserve failed attempts to trim the search space.
Diversity collapse: Evolutionary/RL loops tend to exploit known high‑reward patterns. Mechanisms needed to prevent convergence to similar solutions, especially for open‑ended research.
Reward hacking: Self‑improvement optimizes given signals — risk of overfitting to unit tests, judge models, or benchmark artifacts. Evaluators should sit outside the evolution loop with held‑out tests, trace audits, and human review.
Long‑term success: Optimization must account for outcomes beyond individual rollouts — e.g., maintainability, ownership boundaries, migration cost, backwards compatibility. Current sandbox‑based RLVR training rarely captures these.
Benchmarks for RSI‑Related Agentic Tasks
PaperBench: Replicate 20 ICML 2024 Spotlight/Oral papers from scratch. 8,316 rubrics. Best model (Claude 3.5 Sonnet, ~21%) below ML PhDs.
CORE‑Bench: Computational reproducibility of 90 published papers (CS, social science, medicine). 270 tasks. Best agent (GPT‑4o/‑mini) 21% on hardest difficulty.
ScienceAgentBench: 102 tasks from 44 peer‑reviewed publications (math, chemistry, biology, geography) covering data processing, model development, analysis, visualization.
RE‑Bench: 7 open‑ended ML research‑engineering environments against human experts. Human experts scored non‑zero in 82% of 8‑hour attempts; best AI agents scored 4× higher at 2‑hour budget, but humans exceeded at 8‑hour and 32‑hour.
MLE‑bench: 75 offline Kaggle competitions. Best setup (o1‑preview with AIDE) reached at least bronze level in 16.9% of competitions.
KernelBench: 250 PyTorch tasks for GPU kernel correctness/speed. Metric fast_p = percentage correct and faster than baseline.
As the model becomes more intelligent, the optimization target becomes more complex and generic. Many harness improvements may eventually be internalized into core model behavior, but the interface with external context and tools will remain.
Human Oversight
Human oversight must move up the stack, not be removed. System design should set touch points at the right time and abstraction level. Many challenges require human feedback and steering; the technology is built for a better future of humanity, not the other way around.