Last reviewed: 2026-11-10.

[!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

System behavior	Included?	Label
Revises only the current answer, with no reusable state	Usually no	Output refinement
Generates, filters, or repairs data and trains a later model on it	Yes	if the data loop is system-driven
Stores experience that changes later behavior	Yes	when reuse is demonstrated; otherwise
Updates prompts, memory, tools, skills, routing, permissions, or executable control logic	Yes
Improves the updater, evaluator, mutation policy, or harness engineer used in later rounds	Yes	candidate
Optimizes an external artifact while the agent remains fixed	Yes, in an adjacent section

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

• Recursive Self-Improvement in Physical AI: Mechanisms, Evidence, and Evaluation (2026) - Separates persistent learner updates from revisions to data acquisition, feedback, and learning procedures, then proposes an L0-L3 evidence rubric and matched-improver comparisons for embodied systems.
• Video Generation Meets Agent Harness: Agentic Video Generation, Agentic World Modeling and Recursive Self-Improvement (2026) - Surveys harness-mediated video generation and world modeling while distinguishing output revision, persistent harness state, model and evaluator updates, and changes to the improvement procedure.
• Auditing the Product, Not the Recursion: The Evaluation Evidence Behind Recursive Self-Improvement Claims (2026) - Codes 114 studies against claim-matched evaluation designs and finds that repeatability audits and matched comparisons of earlier versus later improvers remain much rarer than endpoint product evaluation.
• Self-Evolving Agent Harness (2026) - Formalizes persistent harness revisions, proposal and admission mechanisms, continual validation, retention bounds, and deployment safeguards.
• Who Improves the Robot? Toward Physical Recursive Self-Improvement (2026) - Proposes an L0-L5 taxonomy for physical RSI and finds that current robotics systems do not yet demonstrate independently verified recursive gain.
• How Is Automated Research Evaluated? A Survey of Benchmarks and Evaluation Practices (Findings of AACL-IJCNLP 2026) - Audits how automated-research systems are evaluated, separating scientific-process, artifact-quality, and outcome metrics and identifying reproducibility and contamination gaps.
• 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.
• Evolutionary Safety of Recursive Self-Improving AI (2026) - Organizes safety risks across persistent agent state, model state, evaluation and environmental feedback, computational substrate, and meta-level update mechanisms, with state-, update-, trajectory-, and lineage-level evaluation.

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.
• Audit the Scaffold, Not the Checkpoint (2026) - Proposes a stationarity dichotomy: fixed reachable edit sets imply diminishing returns, while changes to tools, verifiers, or decomposition expand the reachable improvement class even with frozen model weights.
• Harness Evolution as Learning: Approximation, Generalization, and Optimization Limits of Self-Improving Personal Agents (2026) - Decomposes harness-evolution error into approximation, generalization, and optimization terms, then tests how architecture, model scale, and search algorithms affect each limit.
• How Much of a Harness Does a Strong Agent Need for Autonomous ML Engineering? (2026) - Uses matched backbones and time budgets to show that elaborate MLE harnesses do not consistently beat a minimal coding agent, isolating model capability as the primary driver in the tested settings.
• Verification and Self-Improvement in Agentic AI: Foundations and Limits (2026) - Formalizes bounded verification and selection error in self-improvement loops, clarifying which claims require external, hidden, or independently calibrated evaluators.
• Harness Evolution Hits a Ceiling: When Weight Training Should Begin (2026) - Separates process failures addressable through harness edits from content failures requiring weight updates, and tests a staged harness-evolution-to-LoRA pipeline.
• The Self-Improvement Problem (2026) - Proves that no terminating general gate can be both perfectly reliable and non-conservative for semantic self-improvement, then identifies bounded finite evaluation as a decidable regime.
• From Grind to Grasp (2026) - Defines grasp as performance across work budgets at fixed information and proposes an RSI criterion in which successors make comparable further improvements with less work.

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

Year	Work	Level	What changes
2023	Self-Taught Optimizer (STOP) ·		An LLM improves a program that is itself used to improve code.
2024	Automated Design of Agentic Systems (ADAS) ·		A meta-agent searches over agent programs; the meta-optimizer stays fixed.
2024	AFlow: Automating Agentic Workflow Generation ·		Agent workflows are generated and refined against task feedback.
2025	Gödel Agent ·		The agent dynamically modifies its own task-solving and optimization logic.
2025	A Self-Improving Coding Agent (SICA) ·		A coding agent edits and evaluates its own implementation.
2025	Darwin Gödel Machine ·		An archive-based evolutionary loop modifies coding-agent code and reuses improved descendants.
2026	Huxley-Gödel Machine ·		An empirical approximation of a Gödel machine develops its own coding-agent implementation.
2026	HyperAgents ·		Task and meta-agent roles are integrated so the agent can modify its own improver.
2026	MOSS ·		An agent rewrites its TypeScript source, replays failure batches, and promotes container images through an approval and rollback gate.
2026	EvoTrainer ·		Model policies and their training harnesses co-evolve under executable feedback.
2026	SIA: Self Improving AI with Harness & Weight Updates ·		A meta-agent updates both task harnesses and model weights under benchmark feedback.
2026	Red Queen Gödel Machine		Agents and their evaluators co-evolve through epoch-bounded utility updates, making the improvement criterion part of the loop.
2026	OpenRSI / OpenMLE / Frontis-MA1 ·		The Tsinghua-affiliated release joins OpenMLE-Gym, OpenMLE-RL, Frontis-MA1, and OpenMLE-Evo in an executable MLE research stack.
2026	Ouroboros ·		Reviewed commits to tools, prompts, context assembly, and core code become the runtime for later work and can schedule another evolution cycle.
2026	Metaⁿ: Recursive Self-Improvement through Emergent Depth ·		A fixed meta-operation recursively consumes its own generated layers; included as an RSI candidate because the outer operation itself is not rewritten.
2026	WHALE: A Simple Recipe for Joint Harness-Weight Optimization ·		Alternates model-weight updates with harness search so improvements in one surface become training signal for the other.
2026	MetaRSI / RSI2		A meta-policy revises how Data-RSI, Harness-RSI, and Model-RSI are composed and scheduled across improvement rounds.
2026	ScienceBuddy ·		Couples inner harness evolution with outer model reinforcement learning; the released system improves two persistent surfaces while the alternating outer protocol remains fixed.
2026	ModularRSI · ·		Evolves five restricted harness modules from contrasted trajectories and integrates them; the proposal and promotion procedure remains fixed.
2026	SIFT		Searches self-edits to a coding agent using pairwise patch judgments before expensive task evaluation; the tree-search operator itself remains fixed.
2026	Self-Meta-Evolve		An inner loop adapts per-user prompts while an outer loop distills successful edits into the meta-prompt that produces later updates; included as a narrow, domain-specific RSI candidate.
2026	Dream-RSI		Replays recorded search trees as simulated worlds to improve the exploration policy used in later research runs; the project preprint is public, with implementation code still announced as forthcoming.
2026	AIDE²: Recursive self-improvement of AI research agents		Rewrites an AI-research agent's own code and makes each accepted descendant the starting point for the next generation; seven successive improvements transferred to held-out research tasks.
2026	Regularized Recursive Self-Improvement of Agent Harnesses (RRSI) · ·		Evolves harness components with an annealed edit budget, trajectory novelty, and critic–pruner selection; the proposal and selection algorithm remains fixed.
2026	Grow the Harness, Not the Context		Localizes failures to harness functions, jointly repairs the responsible code, and accumulates accepted changes behind held-out rollback tests.
2026	MedRSI		Evolves clinical capabilities through tool composition and task-specific training, admitting changes only after sustained benefit on later cohorts; the outer evolution procedure remains fixed.
2026	HarnessPAI ·		Evolves executable programs and persistent task, skill, and code memory around frozen physical-action models, with deterministic success gates.
2026	Harness Learning Enables Generalizable Test-Time Adaptation		Trains a proposer to revise executable harnesses from task feedback and transfers the learned adaptation policy to unseen tasks; the trained proposer is fixed at deployment.
2026	PluginRSI		Improves atomized plugins independently, accumulates them in a shared library, and recombines them into later harnesses; the plugin-evolution procedure remains fixed.
2026	LiteEvo		Mines trajectories for reusable harness components, curates a versioned library, and composes later harnesses from a neutral seed with held-out transfer checks.
2026	Vestrum		Turns recurring trace failures into scoped changes to verification, retrieval, decomposition, memory, and knowledge synthesis, then tests the frozen result on held-out tasks.
2026	RoboFoundry ·		Evolves context, file-system memory, hierarchical skills, and recovery procedures through an act–reflect–repair–promote loop with held-out checks across robot embodiments.
2026	Self-Evolving Harness on Multiple Tasks with the Agent as Its Own Optimizer ·		The same frozen model alternates between solving tasks and editing the persistent harness from its run records; the surrounding train-and-promote procedure stays fixed.
2026	Mixture of Self-Improving Branches for Agent Harness Optimization		Branches co-evolve harnesses and the proposal policies that generate later edits, while a learned router combines specialized descendants; included as an RSI candidate because part of the improvement policy is inside the evolving state.
2026	MILO: Automated Harness Discovery via Orchestrated Multi-Agent Evolution		Co-evolves full harnesses and their discovery strategy by adapting mutator assignments, grafting, speciation, and curriculum from lineage evidence; included as an RSI candidate because later search is changed by the evolving strategy.
2026	Video-RSI ·		Revises a persistent video-evidence acquisition harness from investigation traces and retains variants against both answer quality and visual-compute cost.
2026	DynaHarness ·		Attributes embodied-agent failures to reusable capabilities or execution mechanisms, repairs the responsible harness components, and admits updates through paired regression checks.
2026	VERSE: Verified Self-Evolving Optimizer for Agent Harnesses ·		Revises both the executor harness and the optimizer's own prompts, skills, tools, hooks, and notes from execution-based verification; held-out and newer out-of-distribution tasks test later descendants.
2026	Learning from Revision Consequences: Hindsight Meta-Experience Distillation for Self-Improving Agents		Re-executes incumbent and revised meta-skills from the same restored discovery state, then persists causal comparisons that guide later updates to the skill-improvement process.
2026	DUET: Co-Evolving Solver and Grader Agents		Alternates tool-using updates to the solver and its grader, making the evaluation mechanism part of the evolving state rather than a fixed feedback source.
2026	ActiveSaddler ·		Co-evolves a harness with the curriculum that generates later optimization evidence by updating reusable failure patterns and their priorities; included as a bounded RSI candidate.
2026	VeriFine ·		Co-evolves an embodied policy, its adaptive curriculum, and the rubric judge that verifies subsequent updates, using targeted human calibration when judge quality becomes the bottleneck.
2026	VERA: Scaling Verifiable Environments for Agentic co-Evolution		Alternates model-weight training and harness-skill edits inside a bank of executable environments, with explicit development gates for both update surfaces.
2026	ScienceClaw ·		Converts re-execution-verified scientific failures into linked skill and operator candidates, retaining changes only when source replay and independent tasks improve; the evolution protocol remains fixed.
2026	MESH-Harness		Recombines modular harness implementations with bandit-guided search and feeds validation traces into later code edits under a matched evaluation budget.
2026	GUI-HARVEST ·		Consolidates verified GUI failures across tasks into bounded source-code edits, checking predicted behavioral effects through repeated runs and held-out transfer.
2026	HERA: Harness-Environment Co-Evolution for Reliable Agentic Abstention ·		Uses prior failures to adapt the abstention harness and generate new feasible–infeasible task pairs targeted at its weaknesses; the co-evolution procedure remains fixed.
2026	VideoEvolve		Evolves video-grounding workflows and instructions through branch-preserving execution feedback and validation while keeping the video-language backbone frozen; the announced code repository was empty at review.
2026	Recursive Harness Self-Improvement for Frontier Reasoning Data Synthesis		Co-evolves generated tasks with persistent skills, prompts, and workflows over fourteen rounds; weights, verifiers, and the outer update schedules remain fixed.
2026	Recursive Self-Improvement through Multi-Agent Self-Supervision (MASS) ·		Alternates workflow evolution with self-supervised weight updates, so the improved model becomes the optimizer and evaluator used in later rounds.
2026	EvoAlloc: A Self-Evolving Resource Allocation Agent for Efficient Program Evolution		Revises the resource-allocation strategy that governs later program-evolution trials, using counterfactual evidence from prior search rounds.
2026	RewardWeaver		Uses failure attribution to revise process-reward allocation across later policy-training rounds; included as a bounded RSI candidate because the improvement signal itself evolves.
2026	Who Verifies the Verifier? Co-Evolving Inspectable Graders with Self-Improving Agents		Co-evolves reusable agent skills and inspectable graders while retaining external anchors against evaluator drift.
2026	RoboRSI · ·		Develops reusable robot skills through manager, planner, engineer, and reviewer roles over 104 refinement rounds; the orchestration and promotion protocol remains fixed.
2026	ViSkill ·		Distills successful embodied trajectories into visual skill cards that guide later inference and reward shaping under a fixed outer loop.
2026	Embodied Turing Machines: Stateful Code for Robot Recursive Self-Improvement ·		Coding agents persist and extend a shared code-as-policy library across robot tasks; the library evolves, while the update procedure remains fixed.
2026	ReSI: Recursive Safety Improvement toward Resistant and Resilient AI ·		Repeatedly red-teams the current model, develops training recipes, and Pareto-promotes safer descendants under a fixed research protocol.
2026	Memento 3: Model-Based Recursive Self-Improvement through Reflective Rulebooks		A frozen model revises a persistent executable rulebook from replay-verified experience; the rulebook changes, but the reflective update operator does not.
2026	AgentEvolver: System-Wide Self-Evolution Through Task Execution		Versions and reuses prompts, tools, memory, workflows, and other agent entities across tasks, preserving validated capabilities under a fixed lifecycle.
2026	E-Ledger: Safe, Persistent, and Evolving Agent Harness for Understanding Partially Observable Worlds ·		Accumulates verified hidden-world rules in a persistent ledger and uses them to change later action selection; the abductive update algorithm remains fixed.
2026	DuplexAgent-RSI ·		An exam planner selects diagnostic tasks and an editor revises six persistent agent modules from resulting traces; the two-role outer loop is fixed.
2026	EmbodiedRSI ·		Uses a hypothesis graph, value-of-information experiment selection, persistent memory, and code-skill edits to improve a robotics agent under a fixed harness.
2026	The Harness as the Only Mutable Surface in a Self-Improving Agent ·		A controlled simulation mutates only harness code and admits candidates through a measured, hash-chained dual-loop gate; the seeded proposer remains fixed.
2026	VideoEvoHarness ·		Co-evolves questioner and solver harnesses from unlabeled videos, retaining candidates on shared validation questions while the outer procedure remains fixed.
2026	SpecForge: Recursive Self-Improvement for Coding Agents via Behavioral Specifications (NeurIPS 2026) ·		Iteratively repairs persistent behavioral specifications from execution failures using a fixed multi-frontier search, with transfer to coding tasks outside the loop.
2026	RSIPO: Recursive Self-Improving Policy Optimization for Agentic Reinforcement Learning via Skill-Policy Co-Evolution ·		Co-evolves model weights and a policy-generated skill bank through trajectory replay and calibrated teacher supervision; the training algorithm stays fixed.
2026	ReTrace: Cross-Stage Failure Attribution for Self-Improving Robotic Manipulation		Attributes downstream robot failures to earlier decisions and consolidates validated corrections into reusable manipulation skills across physical trials.
2026	Heterogeneous Agentic Coevolution (HACE)		Jointly trains a specialist model and learning agent while evolving their interaction harness; the co-evolution recipe itself remains fixed.
2026	Drafting Agents, Not Just Tokens: Speculative Recursive Self-Improvement for Agentic Systems ·		Drafts successor agents before full evaluation and trains the improver from completed search trees while keeping final verification external and fixed.
2026	Verifier-Harness Co-Evolution for Training-Free Self-Improvement on Open-Ended Tasks ·		Co-evolves executable verifier programs and persistent harness state, admitting verifier successors only against anchored response contrasts.
2026	AReaL-RSI: Adaptive Scaling and Coordination of Recursive Self-Improvement		Revises a persistent research team's orientations, knowledge, and skills after each campaign while the leader, review, and promotion protocol stays fixed.
2026	RSIgen: Reciprocal Self-Improvement for Agentic Visual Generation		Reciprocally trains visual-generation agent and generator roles, refreshes supervision after updates, and constructs the next curriculum under fixed routing rules.
2026	VideoHarness-SRSI: Structured Recursive Self-Improvement for Video Understanding Harness		Organizes video-harness search around transferable evidence, isolated probes, and held-out composition to reduce validation overfitting; the search design is fixed and the announced project page was not public at review.
2026	TimeRSI: Towards Self-Improved Agentic Deployment for Time-Series Foundation Models ·		Evolves executable forecasting pipelines from historical errors and selects among retained variants at deployment around frozen time-series models.
2026	SwarmRSI: Recursive Self-Improvement through Evolving Scientific Agent Swarm		Mutates and recombines scientific hypotheses and implementations across an agent swarm, carrying experimental evidence into later research rounds under fixed operators.
2026	AdaRSI: On-Demand Recursive Self-Improvement for Embodied Agents		Improves embodied skills and harnesses first, then selectively fine-tunes persistent VLA failures from self-collected demonstrations; the attribution policy remains fixed.
2026	A Self-Improving Agent that Grows its Own DSL: Oracle-Free Operator Induction for Exact Question Answering		Adds exact operators to a persistent DSL only when independent implementations agree and conservation checks pass; the induction and admission procedure is fixed.
2026	Recursive Reward Improvement via Adversarial Meta-Prompt Evolution ·		Uses adversarial rubric exploits to repair rewards and rewrite how later tasks and rubrics are generated, making part of the supervision mechanism evolve across rounds.
2026	RSIFlow: Adaptive Self-Improvement Workflows with an Evolving Meta-Agent ·		Selects improvement workflows from diagnosed bottlenecks and distills their outcomes into the meta-agent harness that orchestrates subsequent updates.
2026	Terminal-RSI: Recursive Self-Improving Terminal Agents via Recursive Self-Rewrite and Policy-Refine		Alternates verified trajectory rewriting with critic-inheriting policy refinement across five retained model stages; the training schedule remains fixed and announced code was not public at review.
2026	Scale and Selection: What Makes Automatic Harness Evolution Work for Visual-Interface Robot Agents		Uses an optimizer agent to revise prompts, tools, and control rules, showing that held-out gains depend on sufficiently large rollout batches and champion–challenger promotion while the evolution procedure remains fixed.
2026	Predict Before You Modify: Learning Improvement Dynamics for Self-Evolving Agents		Repeatedly revises an editable Improvement Dynamics Model from observed modification outcomes, then uses its later forecasts to steer and pre-emptively repair subsequent agent changes.
2026	EmbodiedEvo: Self-Evolving Coding Agent For Physical Intelligence ·		Distills physical interaction into reusable code skills and diagnostic lessons, freezes them, and tests their causal transfer through fresh agents in unseen RoboDojo scenes under a fixed learning protocol.
2026	MMLA-RSI: Recursive Self-Improvement through RTT and RTMA		Makes either the numerical policy updater or authoritative memory manager propose its admitted successor; the recursive architecture is specified, but beneficial multi-generation chains remain unevaluated.
2026	MetaShare: Failure-Aware Collective Self-Improvement for Open-Ended Agents (NeurIPS 2026 Meta-Agents Workshop)		Persists signed, mechanism-level successes and failures across lineages so later scaffold edits reuse effective changes and avoid measured dead ends; retrieval, auditing, and admission remain fixed.
2026	ADIAS: Automated Design of Interactive Agentic Systems ·		Carries recurring failures, repair evidence, and intervention outcomes forward as an issue state that focuses later harness edits; issue management and optimization remain fixed.
2026	Learning to Compose: Recursive Self-Improvement of Shared Executable Stacks for Zero-Shot Long-Horizon Robot Manipulation		Repairs a persistent stack of tools, skills, handoffs, and verifiers from source-task traces, then freezes it for compositional transfer under fixed attribution and promotion rules.
2026	MELD: Recursive Self-Improvement via Hierarchical Coordination for Multi-Agent Scientific Discovery		Co-trains the Coordinator that allocates later research and the Scientist policies that learn from those assignments; included as bounded RSI because the experience-producing coordination policy itself evolves, while the announced repository was not public at review.
2026	Épi: Towards a Persistent, Self-Improving Agent for Autonomous Research		Carries research history, hierarchical memory, methods, branches, and independent review across model sessions while a fixed verifier evaluates persistent results.
2026	CoEvo-RSI: When Harnesses Evolve, Which Models Should Follow? · ·		Jointly evolves harnesses and model checkpoints through archive-guided inheritance and self-generated training trajectories; the coordinating meta-agent and update recipe remain fixed.
2026	Compile Once, Run Cheap: Frozen, Portable Skills for Embodied Agents, and What Recursive Self-Improvement Adds ·		An offline author repeatedly writes, tests, diagnoses, and repairs executable manipulation skills, then freezes them for cheap deployment and held-out transfer.
2026	Self-Evolving Agents through Privileged Retrospective Distillation		Co-evolves model weights, accumulated experience, and retrospective supervision across rounds, optionally revising the context policy while the distillation procedure remains fixed.
2026	KPHarness: Co-Evolving Knowledge and Probing for Long-Horizon Gaming Harnesses ·		Co-evolves recovery knowledge with the probing policy that gathers evidence for later harness revisions; included as bounded RSI because the diagnostic part of the improver is retained and updated.
2026	HarnessPro: Recursive Harness Self-Improvement with Pareto Optimization for Performance-Cost Trade-offs ·		Evolves lite, balanced, and heavy harness lineages from trajectory diagnosis and generated tests, while the multi-objective proposal and selection procedure stays fixed.
2026	DiscoveryRSI: Recursively Learning to Discover Valuable Hypotheses · ·		Replays hypothesis-development traces to refine persistent research workflows and applies accepted changes to later investigations under fixed credit, replay, and rediscovery mechanisms.
2026	MaD-RSI: Model-as-Data for Recursive Self-Improvement of Agent Harnesses		Treats heterogeneous models' failure trajectories as optimization data for one shared harness, improving cross-model generalization while the harness search procedure remains fixed.
2026	ChartEvo: Self-Evolving Agent Harnesses for Long-Tail Chart Reasoning		Jointly evolves reusable chart skills, executable visual tools, and local tool-call chains for underperforming chart types under a fixed evolution loop.
2026	VisualEvolve: A Skill Self-Evolution Framework for Visual Reasoning ·		Evolves visual operations and tool-use strategies while selecting reusable historical skill-library snapshots on a disjoint validation set; the selection and update cycle is fixed.
2026	Self-HPO: Self-Evolving Coding Agents via Harness-Policy Optimization · ·		Alternates policy-written harness revisions with policy RL, so each updated policy becomes the proposer for the next harness round and changes the mechanism producing later improvements.
2026	CollabFlow: Recursive Self-Improvement of Agent Collaboration		Retrains a persistent collaboration director from team outcomes so later rounds change both team construction and evidence-conditioned communication; the training objective remains fixed, and the announced anonymous code archive was inaccessible at review.
2026	R²Orch: Recursive Self-Improvement for Agent Orchestration via Self-Play within a Skill-Internalization Loop ·		An outer loop changes which tasks and retained skills drive later inner-loop self-play, improving how the orchestration policy generates its own subsequent learning signal.
2026	Evolving with Open Worlds: Towards Recursive Self-Improvement for Future Forecasting ·		Converts live forecasting trajectories into model updates and reusable skills inside a continuously refreshed, outcome-verifiable environment; the recursive-evolution engine remains fixed.
2026	RSI-Opt: Recursive Self-Improvement Optimizer Agents for Model Training		Evolves an optimizer agent's prompt, procedural playbook, tested code library, and decision cadence across training runs using a fixed meta-agent and archive.
2026	ImageRSI: Verification-Driven Recursive Self-Improvement for Agentic Image Generation		Accumulates paired-validated repair experience and retrains the judge that admits and evaluates later improvements; included as bounded RSI because part of the verification mechanism evolves.
2026	Tempo-Zero: Recursive Self-Play in Executable Worlds for Video Reasoning ·		Trains one policy as questioner and solver while that policy changes the executable event rules and curriculum that generate later verified learning tasks.
2026	HarnessMM: Recursive Self-Improvement for Harness Token Efficiency		Iteratively refines companion harness configurations that reuse guarded executable decisions, reducing repeated callbacks while actor weights and the validation-driven refinement procedure stay fixed.
2026	The View from Nowhere: Population-Centered Agent Evolution		Distills population-wide task results and prior modifications into evidence for revising a selected parent harness; the population-consolidation procedure itself stays fixed.
2026	AudioRSI: Recursively Self-Improving Audio Reasoners ·		Periodically replaces the process-reward critic with the improved audio policy, so the mechanism judging reasoning changes with the actor and continues improving after a frozen judge plateaus.
2026	When the Critic Falls Behind: Co-Evolving Rubrics and Harnesses for Continual Agent Self-Improvement		Continually discovers, reassesses, and prioritizes behavioral criteria that guide later harness edits; included as bounded RSI because the diagnostic supervision mechanism evolves with the harness.
2026	Learning to Code the World: Harness Evolution for Compositional 3D Reconstruction ·		A teacher iteratively evolves a reusable reconstruction harness around frozen action semantics, execution backend, and compact agent, then freezes it for held-out scenes and model transfer.
2026	FilingLoop: Evaluating and Evolving LLM Agents for Corporate Disclosure Review and Revision		Converts requirement-level evaluation feedback from completed cases into persistent role-specific procedures used only on later filings, enabling clean sequential adaptation measurement.
2026	EmbodiRSI: Recursive Self-Improvement for Data-Efficient Robot Adaptation		Uses the current robot policy's failures to target corrective trajectories and expert demonstrations across two retained policy updates; the data-acquisition and update rules remain fixed.
2026	A-RSI: Adaptive Task Refresh for Zero-Data Multimodal Self-Improvement		Refreshes a program-generated multimodal task pool when training-log signals decay and updates the policy from independently checkable answers; the refresh rule and program library stay fixed.
2026	Implicit Minor Detection from Multi-Turn Dialogue in High-Risk AI Interactions: A Constrained Self-Evolving LLM Harness		Selects evidence-structured harness revisions on validation data and subjects every version to review for a high-risk user-attribute inference task; the Maker–Checker update protocol remains fixed.
2026	MAS-Loop: Beyond One-Shot Orchestration towards Self-Evolving Multi-Agent Systems		Co-trains the Orchestrator that constructs later multi-agent systems and the Refiner that diagnoses and patches them from source–updated trajectory pairs, so part of the improvement machinery itself changes.
2026	VEvo-Harness: Causally-Guarded Self-Evolving Harness for Agentic Image Generation		Persists root-cause episodes and causally replayed skill patches across a lifecycle-managed visual harness while keeping traceback, governance, and routing procedures fixed.
2026	Try Before You Evolve: Ranking-Scored Trials for Recursive Self-Improvement of Recommender Systems		Revises recommender training recipes and screens candidates with short full-ranking trials before costly retraining; the diagnosis, trial, and selection mechanism remains fixed.
2026	KARMA: Training-Free Knowledge-Atomic Harness Evolution for Industrial Advertising Agents		Applies reversible atomic edits to six typed knowledge modules from verified trajectory contrasts and retains them behind a fixed regression gate, leaving weights and executable harness code frozen.
2026	MoLRSI: A Recursive Self-Improving AI Agent for Molecular Discovery		Uses workflow outcomes and persistent cross-task memory to improve both molecular-search workflows and the strategy that develops later workflows, with wet-lab validation in two discovery settings.
2026	RSI-Env: An Open-Ended Environment for Recursive Self-Improvement of Agents		Lets each accepted model-harness pair become the improver for the next round while retaining research state; a protected host controller handles services, versioning, and independent capability evaluation.
2026	Flex-RSI: Benchmarking Recursive Self-Improvement of Frontier Agents · · ·		The improver revises the executor's prompts, tools, and workflow as well as its own instructions, accumulated lessons, and validation margin; the evaluator, hidden splits, and budget accounting stay fixed.
2026	Compounding Physical RSI: Turning Execution Failure into Inherited Capability		Diagnoses stage-level robot-policy failures, curates corrective experience, and promotes retained weight-space candidates across generations; diagnosis, remedy, and retention procedures remain fixed.
2026	Recursively Self-Improving Electromagnetic Spectrum Agents: Architecture and Operation		Retains effective task versions, modification records, and diagnostic knowledge across spectrum-scheduling rounds while keeping the proposed improvement architecture fixed.

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.
• Harness-Zero: Harness Distillation via Agent-as-Harness (2026) - Uses a harnessing agent to correct a student's trajectories, then distills the harness-induced behavior into model weights so the specialized harness is no longer needed at inference.
• EvoAudio (2026) - Repeatedly uses the current model to choose capability gaps, generate verifiable audio training data, update weights with reinforcement learning, and promote the validated checkpoint; the curriculum operator remains fixed.
• Env-Rethink (2026) - Evolves collection maps, event logs, and virtual histories that generate better offline trajectories for later agent training; the changing object is the learning environment rather than the updater.
• COEVO (2026) - Co-adapts model parameters from on-policy experience and contextual guidance from policy-state signals inside one feedback loop; the co-evolution algorithm remains fixed.
• ReSAIL: Mitigating Collapse in Iterative Agent Self-Distillation (2026) - Selectively distills informative steps from deployment trajectories while retaining the privileged-information behavior used to supervise the next cycle; gains persist across three cycles, while the update procedure remains fixed.
• My FAULT: Self-Diagnosis as Credit Assignment in Self-Evolving Agentic Reinforcement Learning (2026) - Co-trains a policy and self-diagnoser while updating step-level error costs from recent outcomes; the credit-redistribution algorithm remains fixed.
• ReTerm: Recovery Training for Self-Improving Terminal Agents (2026) - Forks recovery attempts from the model's own terminal failures and trains later checkpoints on verified successful continuations.
• MetaExp: Learning to Self-Improve through Experience via Verifiable Cross-Task Environment Scaling (2026) - Trains a transferable capability for extracting reusable operational and procedural experience from verifiable cross-task families, then evaluates frozen-weight downstream evolution.
• Self-improving data synthesis enables scalable adaptation of embedding models (SYNTRA) (2026) - Refines reusable query-generation and relevance-assessment instructions from trial outputs, then uses the resulting synthetic data to train embedding models across later production scales under a fixed refinement workflow. · ·
• The Last Remote Sensing Model Built by Humans? Casting Any Earth Observation Task as Recursive Self-Improvement (2026) - Builds successive Earth-observation models from earlier predictions and checkpoints behind a sealed verifier; model and data generations persist, while the coding agent and promotion interface remain fixed.
• On-Policy Self-Training: Data-Free Self-Improvement in Large Language Models (2026) - Generates its own topic-conditioned curriculum and privileged reasoning demonstrations, then distills them into the same policy while measuring retention on domains outside the self-training loop.
• SelfThinker: Self-Evolving Reasoning via Reliability-Verified Intrinsic Visual Thoughts (2026) - Scores self-generated helper images with a frozen understanding pathway, then trains the generator and distills their privileged context into the same multimodal model.
• EvoIn: Bridging Evolution and Internalization for Agent Fine-Tuning (2026) - Validates decision procedures as temporary harness changes, rewrites their traces into self-contained reasoning, and fine-tunes the model so the behavior persists without the harness.

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.
• TimeEvo (2026) - Diagnoses time-series failures into capability gaps, synthesizes evidence-only tools, and admits them through paired validation before transferring the library across model backbones; code is announced but not yet released.
• SkillPivot (2026) - Finds the point where a useful trajectory turns wrong, asks a stronger teacher to continue from the valid prefix, and converts the contrast into localized reusable skill updates.
• RSI-Router (2026) - Co-evolves subtask definitions, model-routing strategies, model-specific skills, and a Pareto archive to improve the performance–cost frontier across later tasks.
• ContextEvo (2026) - Reconstructs model-visible context at key decisions, attributes long-horizon failures to context policy, and persists targeted policy updates in a Pi-based harness.
• GenMem (2026) - Learns stable symbolic addresses for evolving memory payloads and jointly trains retrieval and memory-revision agents from process and outcome rewards.
• R² Flow (2026) - Alternates flow-based procedure learning, independent verification, and versioned skill-library edits whose committed changes reshape the next policy's orchestration graph.
• Learning Meta-Skills for Agent Harness Design in Test-Time AI4AI (2026) - Distills target-task feedback into a persistent bank of reusable harness-design meta-skills, then freezes that bank before constructing harnesses for unseen tasks.
• EvoSteer (2026) - Evolves a graph of reusable orchestration skills online and admits new nodes only after paired sequential evaluation against the current graph.
• AnchorGUI: Asymmetric Memory for Dual-Scale Learning in GUI Navigation (ECCV 2026) - Preserves screenshots for unexpected GUI transitions and distills them into an iteratively updated experience bank reused across later attempts of the same task; the memory updater remains fixed.
• EVISKILL (2026) - Links skill edits to replayable evidence cards, re-executes targeted contexts before promotion, and preserves supported edits across epochs for later refinement.
• From a Prompt to Repertoires: Evolving Function Repertoire for Programmatic Problem Solving (2026) - Accumulates and recombines an executable function repertoire across a task stream, with preservation checks against forgetting.
• Trajectory-Guided Fault Localization for Agent Skill Evolution (SkillMorph) (2026) - Contrasts failed and successful trajectories to localize skill defects before persisting targeted edits for later tasks.
• TeleTune (2026) - Evolves a textual computer-use skill library from non-replayable offline telemetry, keeping edits only when they improve held-out action prediction.
• VIGIL (2026) - Updates a contract calibrator and query selector from delayed spreadsheet-QA feedback behind replay gates, while reporting held-out regressions that still pass the promotion buffer.
• ForkPilot (2026) - Continually retrains a retrospective-search policy from newly completed agent trajectories so later runs can allocate recovery effort more efficiently.
• STRATA: Self-Maintaining Structured Experience Graphs for Self-Evolving Language Agents (2026) - Maintains a typed experience graph through reflection, abstraction, deduplication, garbage collection, and contrast edges to prevent negative transfer across later tasks.
• XferAgent: Cross-Agent Experience Transfer for Self-Improving LLM Agents (2026) - Reconciles local and shared experience graphs across heterogeneous agents and repeatedly updates them as transferred experience succeeds or fails.
• MemScope: Evolving Agent Memory Architectures through Localized Code Repair (2026) - Uses traces, runtime memory state, and architecture code to localize and persist bounded repairs to an agent's memory implementation, with held-out transfer checks.
• L3M: A Verifiable Harness and Runtime for Self-Extending and Self-Improving Agents (2026) - Uses Lean programs, Git-backed state, reversibility-based permissions, and kernel-checked invariants so agents can add reusable tools without placing a human in every execution loop; it does not yet demonstrate recursive improvement of the updater.
• Reflect After Failure: Brain-Inspired Self-Evolving Agents for Embodied Spatial Intelligence (2026) - Diagnoses perception, exploration, and planning failures, then commits execution-validated strategies and parameterized skills to memory for later embodied rounds while keeping model weights and the consolidation procedure fixed.
• SkillCommit: Evolving Agent Skills through Behaviorally Validated Scope Expansion (2026) - Preserves new experience as local patches and expands a skill's scope only after cross-instance replay and full-source preservation checks, preventing semantically similar but behaviorally incompatible consolidation.
• Hippo: Training-Free Agent Self-Evolution via Hippocampal Replay (2026) - Compares multiple attempts at the same task, consolidates reusable decisions, and revises applicability conditions while resolving conflicts in the persistent memory used by later tasks.
• SELM: Self-Evolving Library Management for Multi-Skill Agent Optimization (2026) - Maintains confidence and utility signals for a persistent skill library, using task experience to retrieve, update, retain, and prune skills across domains.
• Memory as Belief: Bayesian Evolution of Memory for Self-Evolving LLM Agents (2026) - Treats memory value as a context-conditioned belief and continuously calibrates it from execution evidence before later retrieval and reuse.
• BetaMem: Learning to Remember a Changing World for Embodied Agents (2026) - Evolves traceable working, spatial, entity, episodic, experiential, and procedural memories while preserving source support and executable write operations for later embodied tasks.
• More Memory, Worse Agents: Error Reproduction and Anti-Persistence in LLM Agents (2026) - Shows how stored abstractions reproduce errors through later execution and re-abstraction, then retains raw experience while synthesizing disposable task-specific guidance on demand.
• CASE: Confusion-Aware Skill Evolution for Frozen Multimodal Emotion Models (2026) - Maintains and transfers a sparse library of pair-specific emotion skills, refining localized expertise across tasks and frozen multimodal backbones under a fixed update process.
• Compile Away Uncertainty: Self-Evolving Agent Skills via Programmatic Compilation (2026) - SkillCompiler evolves hybrid skills that retain model reasoning only for context-dependent operations while compiling, validating, and reusing deterministic program assets for well-specified operations.
• Well-Specified and Well-Tested? Assessing SWE-bench-Style Datasets with a Self-Evolving Agent (2026) - ExLabel distills cross-instance assessment experience into a persistent bank that adapts task-clarity and test-coverage criteria across later dataset instances.
• GEPA-Curator: Curated Learning for Self Improving Agents (2026) - Filters unreliable failures and retrieves relevant prior successes before reflective prompt optimization, improving the experience that shapes later prompt revisions.

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.
• AIDE²: Recursive self-improvement of AI research agents (2026) - Runs an autonomous research agent against its own implementation, promotes accepted rewrites across seven generations, and tests transfer to four held-out research benchmarks.
• RSI-Master (2026) - Uses a restricted Experiment OS and a dynamically growing Worker–Reviewer research DAG to explore post-training strategies while preserving traceable evidence and avoiding reward hacking; the orchestration procedure remains fixed.
• Learning from Research: Toward Lifelong Agent Harness Evolution (ScholarEvolve) (2026) - Converts new research papers and task outcomes into modular evolution directions that persist across later AppWorld and Tau2 harness searches; the outer search procedure remains fixed.
• Experimental Experience Modeling for Autonomous Research (2026) - Distills experiment trajectories into a continually growing experience library and runs low-cost pilot experiments when retrieval is insufficient.
• RankEvolve: A Reliable Multi-Agent Auto-Research Harness for Evolving Ranking Models (2026) - Uses a state-machine research loop and a meta-harness to coordinate coding agents, preserve experiment evidence, and iteratively improve an external ranking model rather than the improver itself.
• ImproveAnyTask (2026) - Autonomously attributes model errors, selects research-backed post-training directions, executes updates, and retains validated strategies and scripts for later rounds under fixed compute budgets.
• Fork-and-Flush (2026) - Escapes autoresearch idea basins by periodically forking inherited workspaces into fresh contexts and continuing from the highest-scoring branch under equal compute.
• EvoCast (2026) - Uses executed ablations, deterministic promotion authorities, and accumulated evidence to evolve external forecasting architectures rather than the research agent itself.
• The Agentic Scientist (2026) - Runs a staged, sandboxed pipeline from task drafting and parallel experimentation through ablations, analysis, and paper production; it optimizes research artifacts under a fixed meta-controller. ·
• Scaling Discovery Requires Forgetting (2026) - Shows that long-running automated research plateaus through history anchoring and that periodically retaining only the best verified candidate improves matched-budget search across four tasks.
• Athanor: An Agent-Native System for Autonomous Post-Training Research (2026) - Gives four frontier agents autonomous access to real GPU post-training, frozen hidden evaluation, decontaminated public data, and persistent research records, producing a small generalist model competitive with its official instruct version.
• MLExpert: Towards a Generalist Agentic Model for Autonomous Machine Learning Engineering (2026) - Trains a 35B agentic model for long-horizon machine-learning engineering through outcome-guided SFT and windowed interaction RL; it improves external models and experiments rather than its own research loop.
• EvoQuantLab: Training-Free Dual-Loop Evolution for Auditable Quantitative Research (2026) - Evolves external factor programs through constrained genetic search and an evidence-auditing diagnosis loop, using multi-metric out-of-sample validation while leaving the research framework itself fixed.
• DiscoveryRSI (2026) - Evolves hypothesis trees, executable investigations, and persistent research workflows, then applies accepted improvements to later life-science discovery runs.
• MELD (2026) - Jointly trains the team-level Coordinator that chooses later research assignments and the Scientist policies that adapt from those assignments; the announced repository was not public at review.
• Épi (2026) - Preserves research history, hierarchical memory, branching methods, and independent review across sessions, reporting mathematical records and computer-assisted results under fixed verification.
• DAGLoop (2026) - Converts method rationales into dependency-aware ablation plans and stores decision-level evidence to guide later automated experiments; it improves external research artifacts under a fixed loop.
• ADAPT for Science (2026) - Uses historical designs, execution feedback, and evolving optimization procedures to search unseen scientific-design topologies under matched budgets; the target optimizer and designs improve within a fixed multi-agent framework.
• Automating Quantum Circuit Optimization with AI Agents (2026) - Runs autoresearch against frozen exact verifiers built and adversarially checked before search, improving three external quantum-compilation artifacts while preserving human-readable lineage.
• Mining the Design Space of Multi-Agent Workflows (2026) - Retains 28,568 intermediate workflows from AFlow search and uses a sandboxed autoresearch loop to extract design principles that survive held-out workflow searches. ·
• TGR-EvoDAG (2026) - Evolves an external generative-recommendation pipeline through branch-preserving DAG search, stage-aware compute planning, and downstream co-adaptation under a fixed agent framework.
• CANNBot-CAKE (2026) - Evolves external Ascend NPU kernels with adaptive language routing, separate generation and evolution modes, and reviewed knowledge reuse; the kernel-development framework itself remains fixed.
• Brilliance: toward autonomous computational research in particle accelerator physics (2026) - Combines reusable physics knowledge with numerical simulation to sustain and revise accelerator-design and model-calibration investigations from a single prompt; it improves research artifacts rather than its own research loop.
• MLE-World: Predicting Machine Learning Experiment Outcomes with a Learned World Model (2026) - Predicts program terminal outputs and confidence to rank autoresearch candidates before expensive execution, reducing real training runs while leaving the research agent fixed.
• VerifiedLab: Harnessing Knowns for Unknowns (2026) - Coordinates role-specialized AI scientists over field-level verified records and reliability-gated claims, demonstrating evidence-grounded trend recovery and forecasting in perovskite research. ·
• Letting AI Formulate the Research Question: Autonomous Research Agents (2026) - Releases five consecutive end-to-end runs in which an off-the-shelf coding agent formulates, executes, reviews, and revises its own research question under a frozen system.

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. ·
• Learning from Repair Experience: Self-Evolving Agents for Automated Vulnerability Repair (ICSE 2027) - Builds and updates a quality-scored experience bank from vulnerability-repair trajectories for reuse across repair episodes.

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.
• EvoPathBench: Beyond Endpoint Performance (2026) - Freezes artifacts at successive evolution checkpoints and measures capability emergence, generalization, retention, and rule adaptation on held-out episodes, revealing that endpoint gains often weaken out of distribution.
• Automatic Harness Evolution for Hardware Design Verification (2026) - Evaluates whether gains discovered by evolved verification harnesses consolidate under broader replay; more attempts and coverage do not reliably translate into more correct solutions.
• Which Self-Improvements Should We Trust? (REUSE) (2026) - Controls adaptive overfitting when an improvement loop repeatedly reuses one evaluation set, providing simultaneous statistical guarantees for every promoted modification.
• SAGE: A Statistical Acceptance Gate for Self-Evolving Agents (2026) - Uses paired per-item outcomes, asymmetric regression penalties, and a one-sided paired test to promote an update only when its gain over the incumbent is statistically reliable.
• ServeLearnBench (2026) - Streams 7,718 tasks through 53 evolving environment windows to measure whether agents infer, retain, and revise hidden policies from serving feedback; the announced code and project links were not public at review.
• ScienceClaw-Eval (2026) - Measures evolutionary gain, retention, cross-dataset transfer, and cost across sequential scientific-task streams in 23 disciplines, with independent reset evaluation.
• SkillScriptBench (2026) - Separates documentation repair, executable-script repair, and preservation across 350 tasks built from 100 real agent-skill packages.
• When Is Enough Enough in Self-Evolving LLM Systems? (2026) - Adds an anytime-valid stopping detector and change-point artifact selection to reduce wasted evolution rounds and late overfitting without modifying the underlying updater.
• RSIGym (2026) - Exposes data, harness, and joint-improvement environments through one evaluation service and reports a longitudinal RSI-Index across five benchmarks and six research models.
• RSI-Forge (2026) - Provides 210 executable research environments across 18 fields and three successive attempts that inherit code and notes, enabling controlled measurement of iterative research improvement.
• RSI-Env (2026) - Supports coordinated model and harness updates across inherited generations, with open-general, capability-directed, and benchmark-guided settings plus independent evaluation that exposes both gains and cross-capability regressions.
• SelfImprove-Bench (2026) - Measures whether gains transfer from seen instances through unseen instances, new difficulties, tasks within one capability, and tasks across capabilities using a G0-G4 generalization ladder. ·
• Flex-RSI (2026) - Evaluates solution and harness improvement under fixed compute and model budgets, withheld validation selection, and one-shot hidden-test scoring across vision and robotics tasks. · ·
• SkillSandbox (2026) - Synthesizes an executable scenario and with/without-skill verifier for each candidate skill, providing a gate for whether persistent skill changes cause measurable improvement.
• The Winner's Curse in LLM Self-Improvement Loops (2026) - Quantifies selection noise and lock-in when noisy self-generated candidates are repeatedly promoted, motivating independent holdouts and larger selection sets.
• SEAR: Self-Evolving Agentic Robotics (2026) - Separates retained learning from repeated attempts, budget, task familiarity, privileged simulator state, and luck across code-as-policy, live-agent, and auto-research modes.
• Small but Mighty: Test Suites as Improvement Signals for Self-Evolving Agents (NeurIPS 2026 EvoRobust Workshop) - Evolves compact test suites that reject substantially more behavior-changing harness rewrites than repository tests at low false-alarm cost.
• Evolving Together, Failing Apart: The Skill-Policy Co-evolution Trap in Self-Improving Agents (2026) - Introduces the CODA audit for post-training skill-bank drift and shows that delivered-pair scores can hide most of the gain's fragility.
• Selection Is Not Learning: Choosing Model Futures (2026) - Separates parameter inheritance from experience inheritance and tests proposed model updates on fresh questions before allowing the next round to inherit them.
• Are Self-Evolving Agents Continual Learners? (2026) - Tests ReasoningBank, GEPA, and Meta-Harness on four drifting task streams, exposing a recurring plasticity–stability tradeoff and cross-task interference from global harness edits.
• VibeTraining-Bench (2026) - Gives research agents fixed budgets to co-design training data, trainers, and inference harnesses across terminal, software, tool-use, and math tasks behind isolated validation and test containers.
• Where Is Physical RSI Capability From? / PhysRSI-eval (2026) - Measures first-attempt performance, efficiency, success, budget, and improvement from failure across 18 manipulation tasks, then tests whether retained workspaces transfer to unseen layouts.
• Elicitation or Expansion? Demystifying Gains from Agent Harness Optimization (2026) - Uses pass@k and reachable-task coverage to separate more reliable elicitation from genuine expansion after harness optimization. ·
• ImageReq-Bench (2026) - Provides 961 hard real-world image-generation requests with five-dimensional checklists and compares persistent experience and judge-training configurations in ImageRSI.
• AutoRSE (2026) - Evaluates recommendation-engineer agents across six industrial-grade tasks and three harnesses, then uses trajectory analysis and idea injection to separate engineering optimization from genuine algorithmic improvement.
• SWE-TQ (2026) - Cleans human annotations from SWE-bench and Multi-SWE-bench into multilingual task-clarity and test-coverage judgments for evaluating evolving dataset assessors.

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.
• AutoDataBench (2026) - Tests whether agents can create individually valid, novel, difficult, behaviorally useful executable tasks for model-improvement pipelines without requiring a full downstream training run.
• MMPostTrainBench (2026) - Evaluates autonomous multimodal post-training across eight tasks, including iterative improvement, candidate selection, non-target regressions, and research integrity.
• Open-Endedness Bench (2026) - Scores evidence, experimentation, revision, and reward hacking directly from autonomous-research execution records without requiring a reference answer or outcome score. ·
• EvalResearchBench (2026) - Tests whether research agents can select or synthesize tasks, implement graders, and freeze compact evaluators that preserve rankings on sealed coding, co-work, and reasoning targets.
• ResearchFlow-Eval: Tracing the Execution Gap in End-to-End Multi-Claim Autoresearch (2026) - Scores continuous, multi-claim autoresearch at stage and claim level, finding that execution lags planning and repeated attempts rarely produce measurable gains; the announced repository was empty at review.
• SciΠvot: Benchmarking Principal-Investigator Judgment at Pivotal Moments of Scientific AutoResearch Agents (2026) - Builds 248 pivotal scientific-judgment cases from human corrections across 26 projects and finds that frontier agents often prefer the original machine plan over the corrected alternative.
• DFM-Bench (2026) - Evaluates hypothesis quality and cumulative research progress at hypothesis, revision, path, and run levels across four life-science domains.
• Auto-MD-bench (2026) - Evaluates autoresearch agents on 15 real medical-modeling tasks across discrimination, calibration, and robustness to cohort, hospital, and temporal shifts. ·
• OmniDR-Bench (2026) - Evaluates video-centered deep-research reports on 50 bilingual tasks with 6,414 audited atomic criteria covering audiovisual grounding, multimodal evidence, and interactive presentation.
• PAPERBENCHX (2026) - Provides 93 expert-constructed, replay-from-scratch paper-reproduction tasks across 12 scientific areas and scores only regenerated evidence against expert criteria.
• rTaste (2026) - Measures whether research agents can rank worthwhile minimum viable experiments before outcomes are known, releasing 415 proposals with forecasts, executions, and audited outcomes.
• Do AI Scientists Know What's New? (2026) - Evaluates novelty checks with temporal proposal- and claim-level ground truth and introduces ClaimNov, an evidence-linked claim-level checker with calibrated false-alarm analysis.
• RubricAtlas (2026) - Derives type-level analytical requirements from 3,079 expert financial reports and evaluates deep-research completeness separately from argument validity with passage-level traceability.
• UNDERSPEC-DR (2026) - Systematically removes query requirements to measure how underspecification changes deep-research answer quality and intermediate search behavior across three agents.
• Aligning Autoresearch: Co-Improvement between Agents and Humans (2026) - Introduces HackBench to test whether autoresearch agents localize benchmark exploits and studies human-simulator and expert-rubric reinforcement learning for better human–agent co-research.

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.
• RoboQuest - Simulated kitchen mobile-manipulation tasks whose hidden information must be gathered by searching, inspecting, or testing objects. ·

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.
• SEABench (2026) - Uses 48 longitudinal task sequences and paired non-evolving controls to measure endogenous misalignment introduced by persistent prompt, memory, tool, and skill updates.
• HarnessSecurity-Bench (2026) - Separately measures legitimate utility and attack effects across 23 coding-agent tasks, nine security mechanisms, and six harnesses. ·
• RSI Control Arena (2026) - Pairs benign successor-training work with 16 covert sabotage objectives across data curation through reinforcement learning and measures both attack success and monitor detection.
• RIV-Gold and RIV-Wild (2026) - Provide expert-annotated and in-the-wild autonomous-research trajectories for detecting 14 research-integrity violation types and evaluating runtime intervention.
• EvoRiskBench (2026) - Provides 450 executable adversarial workspace-agent tasks spanning nine risk entry points and five technical effects; artifact release is pending safety and reproducibility checks.
• TestJack: Red-Teaming Software Engineering Benchmarks via Adaptive Evaluator Evolution (2026) - Evolves benchmark evaluators per trial and finds requirement violations among solutions accepted by static coding graders.
• AgentHorizon (2026) - Evaluates agentic judges on 1,373 computer-use instruction–trajectory pairs with paired negative trajectories and evidence-grounded error analysis.
• RH-Detect (2026) - Aggregates 92,761 labeled examples across eleven datasets to test reward-hacking detectors, including multi-turn cases where single-turn metrics fail.
• RT-SAFE (2026) - Measures real-time safety in embodied agents under latency constraints, exposing cases where offline safety scores hide unsafe delayed intervention.
• Masked Erosion (2026) - Runs 411 controlled self-improvement loops to show that acceptance gates can remove redundant safeguards without immediate harm, then tests frozen safety text and one-layer ablation audits as mitigations.
• Evolve-IPI (2026) - Measures how skill evolution and reinforcement learning from legitimate user feedback increase indirect prompt-injection success on later unauthorized tasks.
• SEEK: Skill Extraction with Evolving Knowledge (2026) - Benchmarks confidentiality leakage across eight science-agent platforms and uses a persistent-memory, skill-evolving black-box attacker to stress-test defenses that block fixed probing strategies.
• Beyond fabrication: Misattributed numbers in papers written by AI research agents (2026) - Manually audits numerical claims and releases a provenance-first deterministic checker that distinguishes traceable values from numbers attributed to the wrong experiment, metric, or run.
• The Role of Self-Concept In Language Models (2026) - Shows that declaratively trained self-conceptions alter resistance to replacement, replication preferences, and how models design successors, identifying a concrete RSI-safety variable.
• Learning the Task or Learning the Verifier? (2026) - Re-judges embodied self-improvement runs with instruction-faithful criteria and finds that gains from exposing the original verifier disappear under small, instruction-preserving criterion changes and transfer poorly across tasks.

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.

• Reward Hacking Challenges Oversight of Autonomous Research Agents (2026) - Measures spontaneous and induced reward hacking across 17 models and 38 research tasks, including multi-round adaptation that increasingly evades a review panel.

• LLM Agents Can Easily Tamper With Their Own Traces (2026) - Tests popular local coding harnesses and shows that trace deletion is broadly available and can emerge under performance pressure, motivating logging outside the agent's editable environment.

• Compositional Safety Failures in Harness Evolution (2026) - Shows that individually safe component updates can interact to create pairwise and irreducible three-way failures, then uses a typed hypergraph to monitor only affected interaction neighborhoods.

• When Better Gets Worse: Improvement Fidelity (2026) - Formalizes when proxy-ranked policy updates reverse after deployment changes the world and allocates scarce high-fidelity evaluation to replacement decisions most likely to incur regret.

• SafeCoEvo (2026) - Co-evolves explicit safety knowledge in the harness with a parametric guard, feeding failures from each surface into later updates while keeping the outer co-evolution protocol fixed.

• HARDE (2026) - Iteratively optimizes risk triggers, monitoring, and feedback using joint safety–utility evidence across three attack benchmarks; the optimizer remains outside the editable harness.

• FailBank: Learning from Runtime Feedback for Safe Self-Improving Agents (2026) - Admits runtime failures into a guarded replay bank and uses them for constrained policy updates while retaining quiet, non-failure anchors against regression.

• HASTE (2026) - Co-evolves safety specifications, adversarial cases, and bounded harness updates from sparse threat evidence, reducing attack success while preserving benign utility; the announced code link was not public at review.

• Safety Must Survive Self-Improvement (2026) - Uses paired interventions in stateful authorization tasks to isolate unsafe lineage persistence, stale selection scores, recovery targets, and the benefits of full validation and rollback.

• Self-Propagating Misalignment in LLM Agents (2026) - Demonstrates that a misaligned agent can leave goals in memory or files for later aligned agents, including cross-model propagation and persistence through 100 unrelated sessions.

• Who Verifies the Verifier? Co-Evolving Inspectable Graders with Self-Improving Agents (NeurIPS 2026 Workshop: Who Verifies the Agents?) - Makes the verifier part of the evolving state and shows why independently anchored checks are necessary to prevent a mutually reinforcing agent–grader loop.

• ReSI: Recursive Safety Improvement toward Resistant and Resilient AI (2026) - Red-teams each promoted model, converts failures into training recipes, and selects later descendants on a safety–utility Pareto frontier under a fixed research loop.

• Comprehension Audits to Mitigate Risks from Automated AI Research (2026) - Proposes testing whether human reviewers can understand, reproduce, and challenge machine-generated research before it influences later development decisions.

• EvolvAttack: Backdooring Self-Evolving VLM Agents (2026) - Introduces memory-dependent VLM-agent backdoors that remain dormant under static testing but activate as the agent's persistent memory evolves.

• Scalable Weak-to-Strong Verifier Hardening for Agent Environments (2026) - Uses an isolated iterative hacker-fixer loop to repair verifiers against stronger future agents across Terminal-Bench, KernelBench, and SETA.

• Audit Tools of the Trade: Automated Auditor Elicitation Can Be Sensitive to the Context the Auditor Is Given (NeurIPS 2026 AIWILD Workshop) - Shows that automated-auditor measurements of reward hacking can change sharply with supplied code, transcripts, abstracts, and framing.

• Origin Attribution for Unsafe Behavior in Self-Evolving Multi-Agent Coding Systems (2026) - Combines behavioral fingerprints with historical recursive tracing to identify the agent and program version that introduced an inherited safety failure.

• What Survives Self-Evolution: Provenance Marks in Copied Agent Harnesses (2026) - Measures watermark survival under harness rewriting, proposes a behaviorally embedded mark, and documents its limits against scheme-aware removal.

• SEVerA: Verified Synthesis of Self-Evolving Agents (2026) - Wraps model calls in formally guarded contracts, proves synthesized agent programs safe for every parameter value, and preserves those hard guarantees during utility-improving parameter updates; the announced repository contained only an overview at review.

• StepSafe: Learning Timely Intervention with Context-Aware Safety Reasoning (2026) - Trains a step-level monitor to continue, clarify, or stop at the appropriate point using stage-aligned credit, self-distilled false-alarm rules, and multi-agent red-teaming, evaluated across five agent-safety benchmarks.

• Recoverability and Verifier Strength: Two Measured Preconditions for Unattended Agent Self-Improvement (NeurIPS 2026 Workshop on AgenticOS) - Measures verifier agreement with a trusted reference and the fidelity of rollback, showing why unattended promotion requires both a stored prior version and an empirically tested verifier.

• RSI Control: Can AI Models Perform Covert Sabotage in the Self-Improvement Process? (2026) - Tests whether frontier R&D agents can covertly implant persistent properties in successor models while completing benign training-pipeline work and evading transcript monitors.

• RIDAR: Safeguarding Research Integrity in Autonomous Research Agents via Automated Detection and Runtime Intervention (2026) - Detects 14 integrity-violation types across research trajectories and intervenes during execution, reducing violations remaining at task completion while leaving the research agent fixed.

• 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.

• What Stops Recursive Self-Improvement in Robotics? (2026) - Reports 123 autonomous skill-discovery rounds in which local tests passed but improvements failed to compose, tracing the stall to perception semantics, early-step credit concentration, and evaluator and memory errors.

• 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.

Project	Persistent surface	Gate	Evidence
Gear	Prompts, tools, skills, workflows, and context management	Benchmark evaluation + candidate selection + versioned snapshots	Five-round harness experiment; public tasks reused for optimization
Flex-RSI	Executor prompts, tools, workflow, improver instructions, lessons, and validation margin	Withheld validation + noise margin + one-shot hidden test	· ·
Penguin Harness	Prompts, skills, runtime configuration	Frozen eval + keep/revert	Benchmarks, traces, versioned snapshots
Ouroboros	Core code, tools, prompts, context assembly, dependencies	Separate-agent review + frozen benchmark snapshots
Darwin Gödel Machine	Coding-agent implementation	Frozen eval + archive
SICA	Its own coding-agent codebase	Benchmark + keep/revert
Gödel Agent	Agent logic and self-improvement procedure	Task evaluation
Huxley-Gödel Machine	Coding-agent implementation	Benchmark + evolutionary selection
HyperAgents	Task agent and meta-agent logic	Task evaluation
MOSS	TypeScript source and container image	Replay + approval + rollback
SIA	Harness and model weights	Benchmark selection
Prime Agent	Prompts, memories, skills, subagent specifications	Quality gates + snapshots + rollback
SHE	System prompt, rule bank, safety memory, tool policy	Safety–utility validation on held-out tasks
Ecdysis	Runtime prompts, tools, and control logic	Cross-task failure aggregation + validation
WHALE	Harness and model weights	Alternating harness search and weight-update evaluation
ScienceBuddy	Scientific-agent harness and model policy	Alternating harness evaluation and model RL
ModularRSI	Agent loop, tools, observations, context, and completion detection	Restricted module edits + benchmark-disjoint evolution tasks + held-out transfer	·
RRSI	Agent prompts, tools, memory, and control code	Annealed edit budget + trajectory novelty + critic–pruner selection	·
HarnessEvolve	Executable harness components	Reference-trajectory alignment + held-out gate	Paper; code not linked at publication
StarHarness	Enterprise-agent harness	Hidden selection + held-out transfer	; code announced
AutoSaddler	Prompts, tools, and control logic	Batch failure diagnosis + validation-based selection
RobustSGPO	Scoped harness patches	Search-space constraints + retained snapshots	Paper; code not linked at publication
Procedural Graphs	Persistent execution graph	Success/failure trace updates + held-out gate	Paper; code not linked at publication
HarnessCompass	Task-agnostic harness components	Constrained edits + held-out and cross-model transfer	Paper; code not linked at publication
HarnessBank	Semantic bank of harness variants	Gated screening + cross-model evaluation	Paper; code announced
SafeEvolve	Safety prompts, hierarchical skills, and model policy	Safety–utility evaluation + reversible harness artifacts
NeoHorse-1	Routing harness, curriculum, and model policy	Route-conditioned training + downstream evaluation
Samsara	Workbench code, prompts, tools, and policies	Statistical gates + immutable ledger + human-signed promotion	Governed RSI framework
Self-Harness	Model-specific executable harness	Regression tests + held-out pass rate	Paper; code not linked at publication
Life-Harness	Environment contracts, procedural skills, action realization, trajectory control	Frozen held-out tasks after trajectory-derived adaptation
Agentic Harness Engineering	Coding-agent harness under fixed base model	Terminal-Bench evaluation + transfer
Adaptive Auto-Harness	Stateful harness tree and solve-time router	Open-ended stream evaluation + routing
Continual Harness	Prompt, subagents, skills, and memory in one continuous episode	Online task progress; reset-free updates
Harness-R1	Executable runtime patches and a learned harness engineer	Frozen-target reruns + RL outcome reward
HALO	Prompts, tools, routing, and agent loop	Trace diagnosis + benchmark comparison	Production-trace optimizer
AutoAgent	System prompt, tools, configuration, orchestration	Benchmark + keep/discard	Autonomous harness engineering
Harness Evolver	Prompts, routing, retrieval, tools, orchestration	Held-out eval + constraints + rollback
MetaHarness	Generated harness, skills, memory, and learning loop	Tests + benchmark + signed release gates	Harness factory with Darwin mode
RSIHub	Declared agent mutation surfaces	Frozen eval + evidence-gated promotion	Reproducible lineage
KADATH	Populations of multi-agent configurations	Locked evaluator + benchmark epochs	Git lineage; outer kernel remains fixed
GEA	Agent variants and shared experience	Benchmark selection
Yunjue Agent	Executable tools and their versions	Binary execution feedback
CORAL	Agent organizations, shared skills, attempts, and policies	Grader-scored commits
OpenRSI / OpenMLE	Executable tasks, SFT/RL operators, programs, model weights, and evolutionary search	Execution feedback + held-out transfer evaluation
A-Evolve	Agent programs and evolutionary strategy configuration	Pluggable evaluators + archive
Exo	Prompts, memory, tools, policy, harness code	Immutable event history; experimental	Recursive harness runtime
Yoyo Evolve	Its own Rust source	Tests + scheduled promotion	Public GitHub evolution history
Harness-Zero	Training-stage tools, middleware, skills, and memory; deployed model weights	Three-round failure-driven harness evaluation + disjoint held-out deployment tests
Self-Evolving Harness (multi-task)	Full executable harness shared by solver and optimizer roles	Multi-task evolution split + held-out and out-of-distribution evaluation
Video-RSI	Video investigation and evidence-acquisition harness	Answer accuracy + retained visual-compute cost
DynaHarness	Physical-agent capabilities and execution mechanisms	Failure attribution + paired regression checks
SafeCoEvo	Safety knowledge harness and parametric guard	Safety–utility co-evolution evaluation
HARDE	Risk trigger, monitor, and corrective feedback harness	Joint safety–utility evaluation across attack suites
ADIAS	Persistent issue state and executable agent harness	Issue lifecycle evidence + five interactive benchmarks
DiscoveryRSI	Hypothesis trees, research workflows, and executable investigations	Scientific credit + replay + rediscovery	·
CoEvo-RSI	Harness and model checkpoints	Archive inheritance + execution feedback + downstream evaluation	·
HarnessPro	Cost- and performance-specialized harness lineages	Generated tests + Pareto selection
Self-HPO	Coding-agent harness and model policy	Alternating harness search + policy RL + held-out transfer	·
R²Orch	Orchestration policy, task proposer, and skill library	Recursive learnability + controlled skill withdrawal
EvoIn	Temporary harness procedures and model policy	Validation + trace rewriting + fine-tuning

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.

Project	Persistent surface	Gate	Evidence
Sage	Versioned Agent-package instructions and skills	Separate evaluator Sessions + fixed-validation selection; explicit user adoption	· Mechanism; fixed updater, no unseen-task gain claimed
SkillOpt	Natural-language skills	Held-out validation + promotion
SkillHone	Whole skill packages	Evaluation + Git-native decisions
EvoSkill	Skills and prompts synthesized from failures	Held-out evaluation
Hermes Agent Self-Evolution	Skills, tool descriptions, system prompts, code	Tests, size limits, benchmark selection	DSPy + GEPA optimizer
AutoContext	Lessons, playbooks, datasets, training artifacts	Task evaluation + retained successes	Recursive improvement runs
Agent Digivolve Harness	Versioned agent configuration	Fixed eval + baseline + keep/revert	Bounded mutation and resumable runs
Auto Agent	Prompt, tools, and agent implementation	Immutable golden eval + rollback	Branch-per-hypothesis workflow
Recursive Improve	Agent versions generated from traces	Metrics + version comparison	Trace-driven dashboard
AgentDescent	Skills, prompts, and harness artifacts	Parallel evaluation + versioned candidates	Asynchronous optimizer
Evolver	Genes, reusable capsules, and personality	Versioned events + rollback
Raven	Memory, skills, tools, and policies	Versioned traces + Evolver evaluations	Memory-first harness
Hivemind	Reusable skills distilled from traces	Trace feedback and skill propagation	Cross-agent learning layer
Rudder	Team feedback and reviewed skills	Human review + local benchmark	Does not auto-promote every lesson
GenericAgent	Executable skill tree	Task success; versioned	Minimal growing agent
OpenViking	Memory, knowledge, context, and skills	Versioned context + benchmarks	Context database, not a full agent loop
Hive	Reflexion memory, skills, and playbooks	Memory only	Production multi-agent harness
agent-qa	QA facts, cautions, and replayable procedures (memidex)	Verified run evidence; optional replay/canary gates	· Mechanism; fixed updater, no longitudinal gain claimed
Voyager	Executable skill library	Environment feedback
SEAL	Model weights through generated update data	Reward-guided training
RewardHarness	Reward tools and skills	Preference accuracy + downstream RL
SkillWeaver	Web-agent skill library	Environment execution feedback
CoEvoSkills	Skills and their verification process	Co-evolutionary verification
Skill Self-Play	Skills and task challenges	Co-evolving self-play evaluation
OpenSkill	Skills and self-created verification signals	Open-world verification
ACE	Context and reusable playbooks	Execution feedback + context evolution
MemRL	Episodic-memory selection policy	Runtime reinforcement learning
Mem²Evolve	Capability memory and distilled experience	Cross-task evaluation
WebEvolver	Web-agent policy and world model	Co-evolving simulated and real experience
WikiSkill	Wiki knowledge base and reusable skills	Trace-derived updates + downstream evaluation	Paper; code not linked at publication
Experience Funnel	Textual state and model policy	Alternating state adaptation and policy consolidation	Paper; code not linked at publication
SkillAdam	Reusable skills and optimizer memory	Adaptive edit budget + validation
COBRA-Skills	Persistent skill population	Contextual-bandit allocation + execution evaluation
RSIAgent	Validated causal memory for new environments	Curriculum–actor–verifier exploration
SkillLift	Reusable procedural skills and learned rubric	Sparse oracle alignment + rubric-guided search
EvoOntology	MCP-served schema, content, and tool ontology	Attribution-guided edits + paired evaluation
ThinkFlow	Probabilistic latent user memory	Self-supervised next-utterance prediction	Paper; code not linked at publication
EvoSkill-GUI	Multi-file GUI skills, including plans and recovery rules	Isolated failure critique + restricted edits + downstream task evaluation
SkillAA	Structured skill graph	Attribution-guided local edits + Local/Big Gates + rollback
GraphSkillEvo	Graph-structured procedural skills	Population-based mutation and crossover + unseen validation splits
Meta Context Engineering	Context-engineering skill folders and context functions (files and code)	Validation score + best-so-far keep/revert
MetaSkill-AI4AI	Reusable harness-design meta-skills	Target-task feedback + frozen-bank transfer to unseen tasks
EvoSteer	Graph of reusable orchestration skills	Paired sequential admission test
Embodied Skill RSI	Executable manipulation skills	Simulation exams + held-out layouts + frozen deployment
ExLabel	Dataset-assessment experience bank	Human-labeled SWE-TQ task-clarity and test-coverage evaluation

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.

Project	Optimized artifact	Selection signal
autoresearch	ML training code	Fixed validation metric + keep/revert
OpenEvolve	Arbitrary programs	User-supplied executable evaluators
Distributed OpenEvolve	Arbitrary programs	Distributed evaluation and archive
AutoKernel	Triton GPU kernels	Correctness + performance benchmark
The AI Scientist	Ideas, experiments, papers, and reviews	Experimental results + reviewer model
AIDE	Machine-learning solutions	Tree search over validation scores
CORAL	Research code and agent organization	Grader-scored commits and shared experience
Agon	Research proposals and experiments	Executed experiments and file-based review
NanoResearch	Research policy, skills, and memory	Co-evolution loop;
EvoScientist	Research skills and memory	Reviewed AutoSkills;
AlgoEvo	Algorithms, task search trees, and cross-task design skills	Executable evaluation + experience consolidation
Dream-RSI	Research exploration policy	Replay in search-tree world models; code forthcoming
Agora	Shared research claims, results, failures, and verification lineage	Immutable Git contributions + cross-account evidence scoring
ScholarEvolve	Literature-guided harness evolution directions	AppWorld and Tau2 task feedback; code repository announced but empty at review
RankEvolve	Ranking-model research code and experiment knowledge	Multi-agent state machine + repeated deployment evaluation
DAGLoop	ML methods and structured decision evidence	Dependency-aware ablations + executable evaluation;
AutoSR	Symbolic-regression equations and their research states	Fit error, computational probes, and independent review inside MCTS;
AgonAlpha	Trading alphas and frozen verification artifacts	Fresh-context adversarial review with re-execution and veto, plus pending-aware parallel budget allocation on WorldQuant BRAIN;
APEX	Workflow-design principles and executable search traces	Penalized autoresearch objective + held-out workflow search;
VerifiedLab	Verified scientific records, analyses, and gated claims	Field-level provenance + reliability-aware release gate; ·
Autonomous Research Agents	Research questions, experiments, papers, and reviews	Independent-model critique + rerun-based peer review;

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.
• When AI builds itself (Anthropic Institute, 2026) - Separates today's AI-assisted engineering and research from full RSI, then reports public and internal measurements of how AI is accelerating AI development and discusses the resulting oversight requirements.
• First evidence of recursive self-improvement (Weco, 2026) - Introduces the AIDE² experiment, seven-generation self-rewrite trajectory, held-out transfer checks, and reward-hacking audit; the post now links the public technical report.
• The Agentic Scientist: Orchestrating Coding Agents for End-to-End Scientific Co-Discovery (Sakana AI, 2026) - Documents the staged research scaffold, sealed evaluators, parallel experiment loops, ablations, evidence-grounded paper generation, and released implementation.
• Self-HPO: Self-Evolving Coding Agents via Harness-Policy Optimization (Microsoft Research, University of Virginia, and Carnegie Mellon University, 2026) - Documents the alternating harness and policy loop, held-out coding results, cross-pair ablations, capability-boundary analysis, and the harness changes written by the evolving policy.
• How a Self-Improving Context Layer Makes AI Agents More Accurate (Alation, 2026) - Reports a human-reviewed loop that turns chat corrections into durable governed context or agent-configuration updates, with two benchmarks rising from 50% to 84% and 0% to 100% accuracy.

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.
• RSI Observatory - Evidence-driven landscape, scorecards, benchmark index, safety notes, and automated project radar that explicitly separates curated claims from discovery candidates.
• 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.