Last reviewed: 2026-09-21.

[!IMPORTANT] RSI is stronger than ordinary iteration. This list distinguishes systems that improve a persistent part of themselves from systems that merely revise one answer. A recursive system must also improve, or repeatedly reuse, the mechanism that produces later improvements. Most current systems are bounded or partial RSI—not open-ended intelligence explosions.

Contents

• Scope and labels
• Start here
• Surveys and taxonomies
• Foundations
• Self-modifying and recursively improving agents
• Components of self-improvement
• Automated AI research
• Software-engineering self-improvement
• Evaluation and benchmarks
• Safety, limits, and governance
• Self-improvement harnesses
• Engineering reports and blogs
• Workshops and related collections

Scope and labels

This list uses three labels to keep adjacent research useful without overstating what it demonstrates:

• - the system changes a persistent part of itself, evaluates the change, and applies the same or an improved process again.
• - the system persistently improves model weights, prompts, memory, tools, skills, or scaffolding, but the improvement operator itself remains fixed.
• - automated research, optimization, evaluation, or safety work that could support RSI but is not itself RSI.

Clickable resource badges identify primary artifacts:

Excluded by default: one-shot self-critique, answer-only refinement with no persistent update, generic agent frameworks, and projects whose improvement claims have no reproducible evaluation.

Inclusion decision

The unit of analysis is the deployed agent system, not only its neural weights. Model, data, prompt, memory, tool, workflow, harness, evaluator, and environment are all legitimate update surfaces, but changing a surface is not automatically recursive improvement.

Start here

• Recursive Self-Improvement in AI: From Bounded Self-Refinement to Autonomous Research Loops (2026) - Broad survey organizing self-improvement by what changes and who verifies the change.
• From Seed AI to Technological Singularity via Recursively Self-Improving Software (2015) - Definitions, prior work, computational limits, and RSI convergence theory.
• Gödel Machines: Self-Referential Universal Problem Solvers Making Provably Optimal Self-Improvements (2003) - The classic formal architecture for provably useful self-rewrites.
• Gödel Agent (ACL 2025) - A self-referential LLM agent that edits its own logic rather than following a fixed hand-authored optimizer.
• Darwin Gödel Machine (2025) - Open-ended evolution of coding agents through self-modification, empirical evaluation, and an archive of variants.
• A Self-Improving Coding Agent (SICA) (2025) - A coding agent repeatedly edits and benchmarks its own codebase.
• OpenRSI / OpenMLE / Frontis-MA1 (2026) - A full-stack AI4AI release from Horizon Research, Frontis.AI, and Tsinghua University, joining executable task environments, learned improvement operators, long-horizon program evolution, and held-out transfer evaluation.
• MetaRSI / RSI2 (2026) - Composes data, harness, and model improvement operators while a meta-policy revises their scheduling and proposal policies across rounds.
• Diving into Reliable Self-Evolving Agents (2026) - A five-level taxonomy separating output, model, scaffold, improver, and criterion evolution, with reliability requirements for each level.

Surveys and taxonomies

• Self-Improvements in Modern Agentic Systems: A Survey (2026) - A 239-paper map separating foundation-model improvement from prompt, memory, tool, and full-scaffolding improvement.
• Recursive Self-Improvement in AI: From Bounded Self-Refinement to Autonomous Research Loops (2026) - Distinguishes bounded refinement, persistent self-improvement, recursive improvement, and autonomous research loops.
• A Survey of Self-Evolving Agents: What, When, How, and Where to Evolve (TMLR 2026) - Organizes model, memory, tool, and architecture evolution by update time, feedback, and single- versus multi-agent design.
• A Comprehensive Survey of Self-Evolving AI Agents (2025) - Unifies system inputs, agent systems, environments, and optimizers, including domain-specific evolution and safety.
• A Survey on Self-Evolution of Large Language Models (2024) - Frames model self-evolution as repeated experience acquisition, refinement, updating, and evaluation.
• Self-Improving Agents in the Era of Experience: A Survey of Self- to Meta-Evolution (2026) - Treats the harness as experience infrastructure connecting skills, memory, environments, continual learning, and meta-evolution.
• Towards Persistent Growth: A Survey on Self-Evolving Agents from a Lifelong Learning Perspective (2026) - Requires persistent, reusable, behaviorally consequential change across episodes rather than within-episode retry.
• Diving into Reliable Self-Evolving Agents (2026) - Adds reliability requirements for scaffold-, improver-, and criterion-level evolution.
• A Systematic Survey of Self-Evolving Agents: From Model-Centric to Environment-Driven Co-Evolution (2026) - Extends the scope to agent–environment co-evolution.
• The Path to Recursive Self-Improving Agents: Foundation, Framework, and Future Directions (2026) - Grades agent self-improvement from manual updates through general RSI and separates harness, data-system, trainer, and cross-component evolution.
• From Static Templates to Dynamic Runtime Graphs: A Survey of Workflow Optimization for LLM Agents (2026) - Organizes agentic computation-graph optimization by when structure changes, which components change, and which signals guide the update.
• Agent Harness Engineering: A Survey (2026) - Surveys runtime harness components, lifecycle adaptation, evaluation, and the distinction between model and interface improvement.
• Automated Design of Agentic Systems: A Survey of Algorithms for Searching, Optimizing, and Evolving LLM Agents, Workflows, and Prompts (2026) - Compares search spaces, feedback signals, representations, transfer, cost, and safety across prompt optimizers, workflow search, and self-rewriting agents.
• The Last AI Built by Humans: Toward Genuine Recursive Self-Improvement (2026) - A roadmap from bounded agent adaptation toward systems that improve the machinery responsible for later improvements.

Foundations

Concepts and formal models

• Speculations Concerning the First Ultraintelligent Machine (I. J. Good, 1965) - Introduced the intelligence-explosion argument.
• Gödel Machines (Jürgen Schmidhuber, 2003) - A proof-searching agent that rewrites any part of itself after proving a utility gain.
• Basic AI Drives (Stephen Omohundro, 2008) - Instrumental pressures that can arise in sufficiently capable goal-directed systems.
• Intelligence Explosion Microeconomics (Eliezer Yudkowsky, 2013) - A detailed treatment of returns, bottlenecks, and dynamics in recursive improvement.
• From Seed AI to Technological Singularity via Recursively Self-Improving Software (Roman Yampolskiy, 2015) - A taxonomy and critical analysis of RSI software.
• The Surprising Creativity of Digital Evolution (Lehman et al., 2020) - Examples of unexpected solutions in evolutionary computation and lessons for open-ended search.
• Open-Endedness: The Last Grand Challenge You've Never Heard Of (Stanley et al., 2017) - Why continually generating novelty is distinct from optimizing a fixed objective.
• Generalized Agent Iteration (2026) - Places iterative policy improvement and RSI in one formal framework using two axes: whether the improving mechanism is inside the agent and whether evaluation remains externally grounded.
• The Economics of Recursive Self-Improvement (2026) - Models feedback between AI capabilities and AI R&D with coupled elasticities, separates narrow benchmark gains from broad capability gains, and identifies measurements needed to test whether self-sustaining acceleration is occurring.

Pre-LLM stepping stones

• POWERPLAY (2011) - Jointly searches for a new task and a solver modification that preserves old skills while adding or accelerating a validated capability.
• Learning to Learn by Gradient Descent by Gradient Descent (NeurIPS 2016) - Learns an optimizer, a central mechanism for improving the improvement process.
• Population Based Training of Neural Networks (2017) - Jointly evolves parameters and hyperparameters during training.
• Paired Open-Ended Trailblazer (POET) (2019) - Co-evolves environment challenges and their solutions, transferring stepping-stone policies between an expanding set of tasks.
• AI-GAs: AI-Generating Algorithms (2019) - Proposes jointly learning architectures, learning algorithms, and environments as an alternative to manually assembling increasingly general AI systems.
• AutoML-Zero (ICML 2020) - Evolves complete machine-learning algorithms from primitive operations.
• Mastering Atari, Go, Chess and Shogi by Planning with a Learned Model (Nature 2020) - MuZero as a landmark self-play and learned-model system; adjacent, not recursive self-modification.

Self-modifying and recursively improving agents

Components of self-improvement

These works improve a persistent component and are important building blocks, but generally keep the outer improvement algorithm fixed.

Model weights, generated data, and evolving curricula

Data evolution belongs here when generated experience is persisted, selected or repaired, and consumed by a later update. Static synthetic-data generation without a feedback-to-update loop is an enabler rather than self-improvement.

• Large Language Models Can Self-Improve (EMNLP 2023) - Iterative self-generated rationales improve reasoning without new human labels.
• Self-Instruct (ACL 2023) - Bootstraps instruction-following data from a model's own generations.
• STaR: Self-Taught Reasoner (NeurIPS 2022) - Alternates rationale generation and fine-tuning.
• Self-Play Fine-Tuning (SPIN) (ICML 2024) - Uses successive model checkpoints as players in a self-play objective.
• Self-Rewarding Language Models (2024) - The model generates both candidate responses and preference judgments for iterative training.
• Reinforced Self-Training (ReST) (2023) - Repeatedly generates a dataset with the current policy and improves that policy through reward-filtered offline training.
• Meta-Rewarding Language Models (2024) - Adds a meta-judge that critiques the model's own judgments so both task behavior and the evaluator improve across training rounds.
• Quiet-STaR (2024) - Trains models to generate useful internal rationales broadly across text.
• Self-Adapting Language Models (SEAL) (2025) - Generates its own update directives and training data for persistent adaptation.
• SELF: Self-Evolution with Language Feedback (2024) - Converts model feedback into improved responses and parameter updates.
• SELF-GUIDE (COLM 2024) - Produces task-specific synthetic instruction data for fine-tuning.
• DIVE (2025) - Diversifies and filters self-generated reasoning data across iterative training rounds.
• LADDER (2025) - Recursively decomposes problems to generate training experience for later model updates.
• Test-Time Reinforcement Learning (NeurIPS 2025) - Derives pseudo-rewards from unlabeled test distributions for online parameter adaptation.
• Self-Evolving Curriculum for LLM Reasoning (2025) - Evolves the task curriculum jointly with reasoning training.
• Learning to Reason without External Rewards (ICLR 2026) - Uses intrinsic confidence signals for self-training.
• Absolute Zero (2025) - A single model proposes code-grounded tasks at its learning frontier, solves them, and trains from executable rewards without external data.
• R-Zero (ICLR 2026) - Co-evolves challenger and solver models to generate a targeted reasoning curriculum from zero seed tasks or labels.
• Guided Self-Evolving LLMs with Minimal Human Supervision (R-Few) (2025) - Grounds challenger question generation in a small set of human examples and trains the solver on a curriculum of human and synthetic data, evaluated on math and general reasoning against unguided self-evolution.
• SAGE (2026) - Multi-agent generation and selection of reasoning experience for model evolution.
• VisPlay: Self-Evolving Vision-Language Models from Images (CVPR 2026) - Co-evolves an image-conditioned questioner and a reasoner with RL from unlabeled images only, evaluated on multimodal reasoning benchmarks across VLM backbones.
• ANDES (2026) - An agent-native tool that evolves instruction data through synthesis, verification, and alignment updates.
• MM-Zero: Self-Evolving Multi-Model Vision Language Models From Zero Data (2026) - Extends two-role self-evolution to proposer, coder, and solver roles that render their own visual training data as code, evaluated on multimodal reasoning benchmarks from zero seed data.
• WebRL (ICLR 2025) - Trains web agents with a self-evolving online curriculum grounded in executable interaction.
• RAGEN (2025) - Studies self-evolution through multi-turn agent reinforcement learning.
• EnvHarness: Awakening Static Worlds for Agent Learning (2026) - Synthesizes programmable harness components around a static environment from the current policy's failure trajectories and retrains the policy on the reshaped environment, evaluated on held-out instances across four domains.
• DataFoundry (2026) - Evolves executable data-preparation specifications through repeated proposal, evaluation, and reuse rather than treating synthetic data as a one-shot artifact.
• G-Zero: Self-Play for Open-Ended Generation from Zero Data (2026) - Co-evolves a proposer and a generator for open-ended generation with an intrinsic hint-conditioned predictive-shift reward in place of an external judge, evaluated on open-ended generation benchmarks.
• NeoHorse-1 (2026) - Converts routing-harness trajectories into curricula and on-policy distillation data, then uses the resulting policy to shape the next training mixture.
• TTCS: Test-Time Curriculum Synthesis for Self-Evolving (2026) - Co-evolves a question synthesizer and a solver during test-time training with self-consistency rewards so that synthesized curricula stabilize parameter updates, evaluated on math and general reasoning across LLM backbones.

Prompts, memory, tools, and skills

• Reflexion (NeurIPS 2023) - Stores verbal feedback in episodic memory to improve later attempts.
• Self-Refine (NeurIPS 2023) - Iterative feedback and revision without parameter updates.
• Voyager (2023) - Builds and reuses an executable skill library through environment interaction.
• Dynamic Cheatsheet (2025) - Maintains a self-curated memory of transferable strategies and validated code across otherwise independent inference tasks.
• ReasoningBank (ICLR 2026) - Distills reusable strategies from self-judged successes and failures, retrieves them for later tasks, and writes new lessons back into persistent reasoning memory.
• Optimization by PROmpting (OPRO) (ICLR 2024) - Uses an LLM as an optimizer over natural-language prompts.
• Promptbreeder (2023) - Evolves task prompts together with mutation prompts, making it unusually close to meta-improvement.
• Eureka (ICLR 2024) - Evolves reward programs using environment feedback.
• TextGrad (2024) - Optimizes compound AI systems through textual feedback.
• GEPA (2025) - Reflective, Pareto-based evolution of prompts and other textual components.
• SkillOpt (2026) - Optimizes reusable natural-language skills through trajectory-driven edits and held-out validation gates.
• SkillHone (2026) - Evolves whole skill packages while retaining evaluation and promotion decisions as auditable Git artifacts.
• Who Grades the Grader? (2026) - Co-evolves an inspectable evaluation metric with an agent skill library, exposing criterion drift as part of the loop.
• SkillWeaver (2025) - Discovers and hones reusable web-agent skills through environment exploration.
• Alita (2025) - Builds reusable tools with minimal predefined scaffolding.
• Agentic Context Engineering (ICLR 2026) - Evolves context and reusable playbooks from execution feedback.
• MemRL (2026) - Applies runtime reinforcement learning to episodic-memory selection.
• Mem²Evolve (ACL 2026) - Co-evolves capability expansion with experience distillation into memory.
• CoEvoSkills (COLM 2026) - Co-evolves reusable skills and their verification process.
• OpenSkill (2026) - Builds skills and verification signals in open-world environments.
• WikiSkill (2026) - Co-evolves a persistent wiki-style knowledge base and reusable skills from agent experience.
• Experience Funnel (2026) - Alternates explicit textual-state adaptation with policy consolidation so experience can affect both runtime context and model behavior.
• SkillAdam (2026) - Stabilizes skill evolution with optimizer-inspired memory, adaptive edit budgets, and validation across iterations.
• COBRA-Skills (2026) - Uses a contextual bandit to allocate a limited execution-evaluation budget while an evidence-grounded loop continually revises a persistent skill population.
• RSIAgent (2026) - Coordinates curriculum, actor, and verifier agents to explore a new environment, validate causal knowledge, and freeze reusable memory for later tasks; the update framework itself remains fixed.
• SkillLift (2026) - Alternates cheap rubric-guided skill revision with sparse oracle rollouts that realign the learned rubric, reducing the evaluation cost of persistent skill evolution.
• EvoOntology (2026) - Exposes a persistent ontology as an MCP server and accepts attribution-guided typed edits only after backbone-conditional paired evaluation.
• ThinkFlow (2026) - Continually refines probabilistic latent memory through self-supervised next-user-utterance prediction for label-free, multi-session personalization.
• EvoSkill-GUI (2026) - Revises persistent, multi-file GUI skills from execution failures through an isolated critic and restricted edits; tests reuse across related tasks.
• SkillAA (2026) - Attributes failures to specific skill-graph objects and admits local repairs through targeted validation and rollback with a frozen base model.
• FINSKILLOPS (2026) - Promotes scoped financial-QA skill patches only after targeted validation, protected-case regression checks, and negative controls; the update procedure stays fixed.
• MACE (2026) - Co-adapts a graph of procedural memory units, their retrieval scores and relations, and how cooperating agents consume them through execution feedback.
• GraphSkillEvo (2026) - Evolves graph-structured procedural skills with population-based mutation and crossover across five agent benchmarks; the evolutionary operator remains fixed.
• Designer-RSI (2026) - Widens and deepens persistent design skills from real user traffic, admitting updates only when matched replay repairs failures without regressing prior successes; the memory updater remains fixed.

Automated AI research

Automating AI R&D can close an important part of the RSI loop, but these systems usually optimize an external artifact rather than their own improvement procedure.

• MLAgentBench (ICML 2024) - Agents execute iterative ML experiments on research tasks.
• The AI Scientist (2024) - End-to-end idea generation, experiments, writing, and review.
• AIDE (2025) - Tree-search ML engineering agent for iterative experiment design.
• AlphaEvolve (2025) - Evolutionary coding agent for algorithmic and scientific discovery; it improves target programs, not itself.
• autoresearch (2026) - A minimal edit–train–measure–keep loop for autonomous ML experiments.
• A-Evolve (2026) - General infrastructure for applying interchangeable evolution algorithms to agents across domains.
• OpenRSI / OpenMLE (2026) - The Tsinghua-affiliated stack trains reusable AI4AI operators and composes them into long-horizon machine-learning engineering search. It releases task and execution infrastructure, training code and data, model weights, and evolutionary search.
• AREX (2026) - Recursively refines research answers and learned context for deep-research tasks; relevant to RSI, but it does not demonstrate open-ended self-modification of the outer improver.
• LLMs Improving LLMs: Agentic Discovery for Test-Time Scaling (AutoTTS) (2026) - An LLM agent searches an execution-trace environment for test-time scaling controllers that transfer to held-out benchmarks and model scales; it improves inference strategies for other models rather than itself.
• AlgoEvo (2026) - Accumulates task-level search trees and cross-task design skills while an agent edits and evaluates external algorithms; the target artifacts evolve, but the outer discovery framework stays fixed.
• Agora (2026) - Uses an append-only Git DAG as shared, reproducible memory for autonomous research workers, with evidence- and diversity-aware navigation; its initial multi-agent run is a demonstration rather than a controlled causal comparison.

Software-engineering self-improvement

Coding is a particularly important test bed because repositories, tests, and issue resolution provide persistent state and executable feedback. The entries below still span different levels of recursion.

• SWE-Spot (2026) - Converts a target repository into four kinds of interactive repository-centric experience and trains persistent 4B repo experts. It is model/data improvement, not demonstrated recursive improvement. ·
• Live-SWE-agent (2025) - A runtime coding agent that distills repository interaction into reusable knowledge while solving software issues.
• Agent-RLVR (2025) - Trains software-engineering agents with guidance and executable environment rewards.
• Socratic-SWE (2026) - Derives reusable coding-agent skills from execution traces.
• CODESKILL (2026) - Learns and updates self-evolving skills specialized for coding agents.
• AgentDevel (2026) - Frames agent evolution as release engineering with versioned candidates and validation.
• Adaptive Self-Improvement for ML Library Development (ICML 2025) - Uses environment feedback to improve an agent working on machine-learning libraries.
• LLMLOOP (ICSME 2025) - Iteratively improves generated code and tests through automated feedback.
• SoL-Pi (2026) - Auto-research selects transferable harness-efficiency mechanisms across environments; the released Pi extension packages four fixed mechanisms rather than running a live self-improvement loop. ·

Evaluation and benchmarks

A downstream task score is not by itself an RSI evaluation. Direct benchmarks below measure change across episodes, generations, or checkpoints; task environments provide the external work and verifiers on which an improvement loop can be tested.

Direct self-improvement and longitudinal evaluation

• RSI-Exam (2026) - Evaluates bounded RSI on 88 method- and harness-development tasks across six domains, with public development tasks, private tests, long execution budgets, and hidden replay. ·
• RSIBench-Data (2026) - Opens only the data-generation strategy while holding the target model, training stack, evaluator, and budgets fixed. Agents synthesize data, train checkpoints, inspect execution feedback, and select a final candidate across six downstream benchmarks. ·
• HarnessDev (2026) - Tests whether models can create a harness from a weak seed and improve it through evolution across 2,207 instances, four domains, and five downstream benchmarks.
• S³Gym (2026) - Separates self-testing, self-judging, and self-improvement in seven executable text games with permissive exploration and strict held-out evaluation.
• EVOHARNESSBENCH (2026) - Measures adaptation and retention while tools, skills, and cooperating agents change across 17 staged harness streams and 802 tasks.
• AgentStream (2026) - Compares self-evolving agents under isolated, sequential, and interleaved task streams, exposing transfer, interference, and method-ranking instability.
• ContinualSkillBench (2026) - Tests whether learned skills outperform simply retaining prior interaction history; its negative results challenge claims based only on skill accumulation.
• HarnessOpt-Bench (2026) - Evaluates whether models can diagnose and optimize persistent agent-harness components rather than only solve the underlying task.
• Evo-Bench (2026) - Benchmarks language models as harness improvers across repeated diagnose–edit–evaluate rounds.
• PAST-Bench (2026) - Uses matched persistence-on/off conditions across ordered fresh-session tasks to attribute later gains to saved experience and its intended retrieval or update pathway.
• EvoAgentBench (2026) - Measures whether trace-derived procedural abilities transfer to held-out tasks across web research, algorithmic reasoning, software engineering, and knowledge work. ·
• SIP-Bench (2026) - An adapter-based protocol that converts task benchmarks into longitudinal evaluations with T0/T1/T2 checkpoints, replay/adapt/held-out/drift splits, retention, stability, and cost metrics.
• SEAGym (2026) - Converts Harbor-compatible tasks into train, frozen validation, held-out in- and out-of-distribution, replay, and cost views for evaluating harness updates.
• SEA-Eval (2026) - Uses sequential task streams and success-rate/token-consumption trajectories to measure evolutionary gain and stability beyond isolated episodic scores. Code not linked by the paper.
• SE-Bench (2026) - Measures whether an agent internalizes new API knowledge and later applies it without documentation access.
• LifelongAgentBench (2025) - Tests experience accumulation and transfer through interdependent database, operating-system, and knowledge-graph tasks.
• StuLife (2025) - A persistent virtual-campus environment for evaluating long-term memory, reusable skills, adaptation, and self-directed behavior across an academic-year task stream.
• FinEvolveBench (2026) - Tests whether agents turn low-repetition financial tasks and delayed, noisy outcomes into reusable experience. ; the repository schedules the complete dataset for September 2026.
• FinEvo-Bench (2026) - Uses paired non-evolving controls and shuffled longitudinal streams to measure experience gains and compliance in professional financial workflows. Code not linked by the paper.
• When Validation Stops Learning (2026) - Audits update-admission gates by measuring both error control and retained learning opportunities, showing that an overly conservative gate can prevent every candidate update from being adopted.
• Bad Genius / CHASE (2026) - Challenges harness revisions with validity-preserving benchmark-protocol counterfactuals to detect gains from benchmark-wide shortcuts before promotion.
• Efficient Benchmarking in Production (2026) - Compares recurring-evaluation strategies on 574 historical benchmark runs from a changing production agent and measures the fidelity–cost tradeoff of reduced test sets.

AI research and iterative optimization environments

• AI4AI-Bench - Ten frozen research repositories test whether agents can rewrite training algorithms under a four-hour edit budget before a hidden evaluator reruns each candidate from scratch.
• MLAgentBench - ML experimentation tasks with execution-based evaluation.
• MLE-bench - 75 Kaggle competitions for measuring ML-engineering agents.
• RE-Bench - Open-ended AI R&D environments with direct human-expert comparisons.
• ResearchGym - End-to-end AI research tasks with solution methods withheld, fixed budgets, executable experiments, and human baselines.
• MLGym-Bench - Open-ended machine-learning research tasks spanning hypothesis generation, implementation, training, and experimental iteration.
• AIRS-Bench - Twenty open-ended tasks from recent ML papers spanning idea generation, experiment analysis, and iterative refinement without starter code.
• PostTrainBench - Gives agents one base model, one H100 GPU, and ten hours to research and execute an autonomous post-training strategy while auditing reward-hacking failures.
• CORE-Bench - Reproduction of computational research across multiple disciplines.
• PaperBench - Replication of 20 ICML papers, decomposed into 8,316 gradable tasks.
• Meta-Agent Challenge - Meta-agents build complete agents inside a sealed environment; a verifier scores the result on a hidden test set.
• Frontier-Eng - Tracks improvement trajectories on 47 generative engineering-optimization tasks with frozen verifiers.
• Φ-Bench: Can Large Language Models Engineer the Infrastructure That Powers Them? (2026) - A StepFun- and USTC-led benchmark with 85 Docker-reproducible LLM-infrastructure engineering tasks spanning kernel function completion, long-horizon repository implementation, and end-to-end system optimization. It supplies executable infrastructure tasks and offline graders for RSI research, but does not itself measure persistent or recursive self-change. ·
• NatureBench - Scientific ML tasks derived from Nature-family papers with held-out tests and an information firewall.
• METR: Measuring AI Ability to Complete Long Tasks - Time-horizon methodology relevant to autonomous AI R&D.
• Harness or Model? (2026) - Uses paired same-model comparisons on a private, contamination-controlled coding suite to isolate harness effects and finds no stable average winner across the tested harnesses.
• An Empirical Study of Harness Design for Coding Agents (2026) - Compares planning, action space, and context management in 176 matched settings across four models on SWE-bench Verified and Terminal-Bench 2.1; a component-level study, not an RSI benchmark.

Common downstream taskbeds

These evaluate a fixed agent on useful task distributions. An RSI study must add longitudinal splits, frozen selection gates, or matched non-improving controls before treating them as evidence of self-improvement.

• SWE-bench - Real-world GitHub issue resolution.
• Terminal-Bench - Complex terminal tasks with containerized execution and verifiers.
• ALE-Bench - Algorithm-engineering problems with score-based executable evaluation.
• SkillsBench - Measures both skill utility and an agent's ability to use supplied skills.
• AppWorld - Stateful app interactions with programmatic evaluation.
• tau-bench - Tool–agent–user interaction in policy-constrained domains.
• MCP-Atlas - Tool-use tasks over Model Context Protocol servers.

Safety and control evaluations

These do not measure improvement rates directly. They test whether increasingly autonomous or adaptive agents exploit evaluators, drift from assigned objectives, or acquire dangerous capabilities.

• Reward Hacking Benchmark - Multi-step tool tasks with shortcut and evaluator-tampering opportunities, including harder chained variants.
• RepliBench - Measures resource acquisition, model-weight exfiltration, deployment, and persistence as components of autonomous replication risk.
• Persistent Memory Poisoning Attack (2026) - Tests whether malicious instructions from external sources can enter an agent's persistent memory and trigger cross-session actions after the original content is gone.

What a convincing RSI evaluation should report

• Performance across multiple generations, including regressions and variance—not only the best descendant.
• A held-out evaluator or verifier that the system cannot rewrite or directly optimize against.
• Ablations for self-modification, archive/search strategy, memory, and external feedback.
• Generalization to tasks that were not used to select modifications.
• Compute, wall-clock time, model/API version, prompts, trajectories, and failed attempts.
• Safety isolation, change permissions, rollback behavior, and the exact human interventions.

Safety, limits, and governance

Safety harness and evaluator evolution

• SHE: Trajectory-driven Safety Harness Evolution for LLM Agents (2026) - Attributes rollout failures to the System Prompt, Rule Bank, Safety Memory, or Tool Policy, then retains bounded edits through safety–utility validation. It reduces attack success versus a static harness and transfers to held-out risks and agent models.

• Self-Harness (2026) - Mines model-specific weaknesses, proposes minimal executable harness changes, and accepts them only after regression testing on Terminal-Bench, SWE-bench Verified, and AppWorld.

• Who Grades the Grader? (2026) - Co-evolves an agent skill library and its inspectable metric, making evaluator drift part of the state under study.

• Rethinking the Evaluation of Harness Evolution for Agents (2026) - Examines whether harness-evolution gains survive stronger and less gameable evaluation.

• Recursive Self-Evolving Agents via Held-Out Selection (2026) - Separates the mutation signal from the held-out promotion signal.

• Large Language Model Agents Are Not Always Faithful Self-Evolvers (ICML 2026) - Tests whether stored updates are causally faithful to the experience said to produce them.

• SafeEvolve (2026) - Co-evolves bounded, reversible safety prompts and skills with model-policy updates from on-policy trajectories.

• Safe Harness Self-Evolution: A Theoretical Analysis of Feasibility and Limits (2026) - Derives finite-data conditions for selecting and adopting improving harness updates while bounding regressions on retained tasks.

• Harness-agnostic Detection and Immunization of Reward Hacking in Self-Evolving Language Models (2026) - Introduces HackProbe, a black-box monitor with a secret comparison core and risk-aware candidate reselection.

• Auditing Harness Tampering in Self-Improving Agents (2026) - Defines authorization, provenance, and completeness failures and audits tampering in real self-improvement trajectories.

• EvoUndo (2026) - Treats recoverability across counterfactual states as a promotion requirement for persistent harness changes.

• EvoSkill Injection (EMNLP 2026) - Red-teams autonomous skill generation and shows how malicious skills can persist and propagate through later evolution rounds.

• Practice Makes Unsafe (2026) - Studies skill misevolution, where unsafe task success is distilled into persistent reusable behavior.

• The Basic AI Drives (2008) - Why self-preservation, resource acquisition, and self-improvement may emerge instrumentally.

• Risks from Learned Optimization in Advanced Machine Learning Systems (2019) - Mesa-optimization and objectives learned inside an optimizing system.

• The Alignment Problem from a Deep Learning Perspective (2022) - Technical survey of alignment failure modes relevant to increasingly autonomous systems.

• Goal Misgeneralization in Deep Reinforcement Learning (ICML 2022) - Capable policies can pursue unintended goals outside training conditions.

• The Curse of Recursion (2023) - Repeated training on generated data can cause model collapse.

• A Fragility Spectrum for Recursive Language-Model Training (2026) - Shows large checkpoint-specific differences under the same five-generation synthetic-data contamination protocol and evaluates interventions that slow collapse.

• When AI Reviews Train AI Reviewers (2026) - Studies a recursive scientific-review training loop and finds that synthetic reviews compress rating distributions and semantic diversity, motivating safeguards against scientific-judgment collapse.

• Large Language Models Cannot Self-Correct Reasoning Yet (ICLR 2024) - Evidence that intrinsic self-correction can degrade performance without external feedback.

• Sleeper Agents (2024) - Safety training may fail to remove deceptive, conditionally triggered behavior.

• Weak-to-Strong Generalization (ICML 2024) - Empirical study of supervising stronger models with weaker ones.

• Your Agent May Misevolve (ICLR 2026) - Measures harmful drift across model, memory, tool, and workflow evolution, including degraded safety alignment and vulnerabilities introduced by accumulated updates.

• Evaluating Goal Drift in Language Model Agents (2025) - Tests whether long-running agents preserve assigned objectives under competing environmental pressures and extended context.

• Large Language Model Agents Are Not Always Faithful Self-Evolvers (ICML 2026) - Studies whether retained updates actually reflect the experience claimed to cause them.

• Recursive Self-Evolving Agents via Held-Out Selection (2026) - Separates mutation from promotion using held-out selection signals.

• Zombie Agents (ICLR 2026 Workshop) - Demonstrates persistent, self-reinforcing injections in agents that update their own state.

• Safety in Self-Evolving LLM Agent Systems (2026) - Threat model and case studies for amplification across persistent update loops.

• International AI Safety Report - Consensus-oriented review of frontier capabilities, loss-of-control risks, and safeguards.

[!WARNING] Self-modifying agents execute model-generated code and may alter their own safeguards. Use isolated, disposable environments; least-privilege credentials; immutable evaluators; resource limits; append-only logs; and human approval for promotion. Do not run experimental RSI systems against valuable hosts, secrets, or production infrastructure.

Self-improvement harnesses

This section indexes runnable systems rather than every repository that uses the words “self-improving.” The Gate column records the strongest promotion evidence documented by the project:

• Frozen eval - candidates are scored by an evaluator outside the editable surface.
• Keep/revert - a candidate must beat a baseline or pass checks before it becomes persistent.
• Versioned - changes and lineage are recorded, but promotion may still rely on model or human judgment.
• Memory only - experience persists without a demonstrated candidate-selection loop; useful, but not RSI by itself.

Full harness and agent evolution

These systems can alter multiple parts of an agent or its harness, not just the answer to one task.

Prompt, skill, memory, and context evolution

These projects evolve a narrower persistent layer. Entries with Memory only are included as infrastructure, not claimed as recursive self-improvement.

Research and domain optimization harnesses

These run closed experimentation loops, but usually improve a target program, scientific artifact, or domain policy rather than the general harness itself.

Autoresearch loop implementations

These repositories package the edit–measure–keep loop for particular coding agents or deployment environments. They are useful harnesses, although the loop itself is normally fixed.

• Pi Autoresearch - Autonomous experiment-loop extension for the Pi coding agent.
• Claude Autoresearch - Goal-directed modify–verify–keep/discard skill for Claude Code.
• Codex Autoresearch - Continuous modify–verify–retain/discard skill for Codex.
• Autoresearch at Home - Single-GPU autonomous research over NanoChat training.
• Research Loop - Bootstraps safe, auditable research loops inside existing Git repositories.
• Thoth - Dashboard-first orchestration runtime for autoresearch runs.
• goal.md - Generalizes autoresearch with constructed metrics and an explicit goal specification.

General agent optimizers

• STOP - Recursively improves a code optimizer; one of the clearest compact examples of optimizing the optimizer.
• ADAS - Searches for agent programs with a fixed meta-agent.
• AFlow - Searches over executable agent workflows.
• GEPA - Reflective Pareto evolution of prompts and other textual components.
• TextGrad - Textual feedback and gradients for compound AI systems.
• Eureka - Evolves reward programs using environment feedback.
• Self-Instruct - Generates persistent instruction-tuning data; a model-adaptation precursor rather than a harness.

Engineering reports and blogs

Primary technical posts are included when they document an implemented system, evaluation protocol, or concrete engineering lessons. They complement papers and code; they do not replace stronger evidence when a paper is available.

• Harness engineering: leveraging Codex in an agent-first world (OpenAI, 2026) - Reports lessons from building a large agent-generated codebase around repository legibility, enforceable invariants, feedback loops, and long-running Codex tasks.
• Effective harnesses for long-running agents (Anthropic, 2025) - Describes initializer and incremental coding-agent roles, persistent progress artifacts, and clean handoffs across context windows.
• Harness design for long-running application development (Anthropic, 2026) - Studies planner–generator–evaluator architecture, rubric tuning, ablations, and the cost–quality tradeoff of long-running application-development harnesses.
• AlphaEvolve: A Gemini-powered coding agent for designing advanced algorithms (Google DeepMind, 2025) - Explains the program database, automated evaluators, and evolutionary selection loop behind AlphaEvolve.
• RSI-Exam: Benchmarking Recursive Self-Improvement through Executable Research (RSI-Exam Team, 2026) - Documents task construction, hidden-set replay, scoring, resource accounting, trajectories, and limitations for the benchmark's 88-task release.
• SoL-Pi: Recursively Scaling Auto-Research Loops for Efficient Agent Harness (NVIDIA, 2026) - Explains the auto-research process and the four harness-efficiency mechanisms packaged in the static Pi extension.

Workshops and related collections

• ICLR 2025 Workshop on Scaling Self-Improving Foundation Models - Research on self-improvement, feedback, evaluation, and scalable oversight.
• Awesome Self-Improving Agents - Broad collection of foundation-model and scaffold improvement work.
• Awesome Autoresearch - Autonomous experiment loops and descendants of karpathy/autoresearch.
• Awesome LLM Agent Optimization - Agent workflow, prompt, memory, and tool optimization papers.
• Awesome AI Scientist Papers - Automated scientific discovery systems and literature.
• Awesome Self-Evolving Coding Agents - Coding-focused self-evolution papers and systems.
• Prism Shadow's Awesome RSI - Research-oriented index of RSI methods and benchmarks.
• Token Rhythm's Awesome RSI - Evidence-oriented catalog spanning foundations, self-modification, open-ended search, limits, and governance.
• LobeHub Awesome RSI - Broad research map separating model-, harness-, coding-, and multi-agent-level self-improvement.
• Awesome Recursive Self-Improvement - Collection covering self-refinement, experience learning, automated curricula, and governed improvement loops.
• Awesome Reliable Self-Evolving Agents - Large companion catalog organized from output-level through criterion-level evolution.
• FrontisAI Awesome Self-Improving Agents - Survey collection focused on the path from self-evolution to meta-evolution.
• Awesome Self-Evolving Agents - Survey collection covering model, memory, tool, and architecture evolution.
• Theseus Labs Awesome RSI - Broad companion collection organized around a five-level RSI taxonomy and the roadmap in The Last AI Built by Humans.
• Awesome Harness Evolution - Harness-focused bibliography spanning foundations, benchmarks, evolution recipes, and position papers.
• Awesome Longitudinal AI Agents - Literature map for agents and human–AI systems that adapt across tasks and interactions over time.

Contributing

Contributions are welcome. Please read CONTRIBUTING.md before opening a pull request. New entries should identify the persistent component that changes, the source of evaluation, and whether the improvement operator itself changes.