The Evolution of AI: The Boundaries and Truth of Recursive Self-Improvement (RSI)

Author: Zhao Zhimin, PhD from Queen's University Canada (Research focus on code intelligence and world models)

If this is your first time hearing about RSI, this article can serve as an introductory guide. We will take you through RSI from the ground up, starting with the earliest attempts at self-improvement in AI, discussing today's agents that can modify code, generate training data, and participate in model development, and see how AI gradually learns to improve itself.

In July 2026, OpenAI released GPT-5.6. For the first time, a somewhat unusual new subject appeared on its report card: Can AI participate in improving AI itself?

OpenAI categorized this ability as self-improvement. GPT-5.6 Sol scored 57.9%, while GPT-5.5 scored 41.7%, a difference of 16.2 percentage points between the two generations of models. It is not about how many conventional problems the model can solve, but whether it can step into the AI development scene: troubleshooting research systems, optimizing GPU kernel programs and training recipes, running machine learning experiments, and even helping to improve another model.

This is not an isolated piece of news. In the same summer, OpenAI began referring to agents as "automated research interns." Kuaishou's AgentX has already involved agents in proposing solutions, writing code, and conducting online A/B tests comparing new and old versions. Google stated that long-running agent cycles participated in refining the next version of the model. Motus2 has brought prediction, evaluation, and strategy updates into real robots.

These cases touch on research execution, industrial experiments, model training, and physical actions, yet none answer the most critical question: Will the improved system be better at completing the next improvement?

This is precisely the question posed by Recursive Self-Improvement (RSI). OpenAI refers to this assessment as the RSI Index, which measures "the ability to achieve RSI." Since the complete questions, task weights, and aggregation formulas have not been disclosed, 57.9% can only be viewed as an internal composite metric, not to be understood as a task pass rate or the "completeness" of RSI.

Even so, these numbers mark a change: a question that previously existed mainly in thought experiments is beginning to be broken down into measurable research capabilities by cutting-edge laboratories.

Researchers have taken forty years to gradually hand over more improvement processes to machines. This article will first clarify several easily confused capabilities and then look at five "boundary advancements" to see which bounded loops have already started turning, why they still do not equate to an "intelligence explosion," and why how the loop closes is more important than whether it closes. These five advancements are merely a narrative framework for sorting history, not a universally recognized technological generation. They overlap in time and continue to develop in parallel today.

What is RSI: From Self-Improvement to Recursive Gains

These news pieces all discuss "self-improvement" but do not explain how a closed loop is defined as complete.

In the traditional sense, Recursive Self-Improvement (RSI) refers to an AI system using its current capabilities to improve the cognitive mechanisms that produced those capabilities. The improved system then participates in the next round of improvements. The most confusing aspect here is that being able to self-improve does not equate to being able to self-accelerate. A system can get better at solving a fixed question bank without becoming better at designing the next round of training. A company can speed up research and development by extensively using agents without forming a compounding effect driven by the improvements themselves.

This concept is not new. In 1863, Samuel Butler imagined machines surpassing humans through iterative evolution. In 1950, Turing proposed the construction of a "Child Machine" that could be educated and self-modified. By 1965, I. J. Good pointed out that if "designing better machines" also requires intelligence, then a sufficiently intelligent machine could design stronger successors, which could continue to improve, leading to an "intelligence explosion."

The crucial point is not whether AI participates in improvements, but whether the improved system becomes better at improving itself. To clarify this boundary, RSI can be broken down into four observable criteria, arranged from easiest to hardest to achieve.

This article adopts the following framework. It is not the only standard definition in academia but aims to separate frequently conflated claims:

• Sustained Improvement: Effective changes can enter weights, memory, tools, or training processes, rather than disappearing after a single response. The weights here, also called parameters, are the set of numbers that the model continuously adjusts and ultimately saves during training. Achieving this criterion is necessary to discuss self-improvement—this article uses this term to refer to improvements in output, memory, parameters, or tools.

• Autonomous Closed Loop: The system can identify problems, propose modifications, conduct experiments, evaluate results, and accept better versions within defined boundaries. A new version can participate in the next round of improvements within this boundary, referred to as bounded RSI in this article.

• Recursive Gains (also called "ignition"): The new version not only scores higher on tasks but is also better at generating the next improvement than the old version. Only by crossing this boundary does "improvement ability itself" begin to compound, referred to as recursive self-acceleration in this article.

• Robustness and Control: Gains persist under fixed resources and hidden evaluations, generalizing to unseen tasks without the cost of evaluation pollution, uncontrolled system complexity, alignment degradation, or lack of auditability (alignment refers to ensuring AI behavior aligns with human intentions and boundaries, not just achieving a high score). All four criteria must be met to approach open-ended RSI.

Currently, the first two criteria have emerged, the third lacks sufficient public evidence, and the fourth remains unresolved. The existence of bounded closed loops does not imply that recursive self-acceleration has been initiated. Only recursive feedback sufficient to offset increasing research difficulty, lengthening iteration cycles, and other resistances will allow improvements to enter a self-amplifying range.

The following text will consistently use four terms. Self-improvement refers to improvements in output, memory, parameters, or tools. A new version can participate in the next round of improvements within fixed boundaries, referred to as bounded RSI. An improved system becomes better at improving itself, termed recursive self-acceleration, which is the "ignition" of the third layer. If this gain can also persist, generalize, and cross the original task boundaries, it approaches open-ended RSI.

Currently, the first two layers have emerged, the third lacks sufficient public evidence, and the fourth remains unresolved. The existence of bounded closed loops does not imply that recursive self-acceleration has been initiated. Only recursive feedback sufficient to offset increasing research difficulty, lengthening iteration cycles, and other resistances will allow improvements to enter a self-amplifying range.

To see clearly which layer we have reached today, we must return to an AI that learned to "cheat" back in 1981.

What is RSI: From Self-Improvement to Recursive Gains

In 1981, Douglas Lenat built a system called EURISKO. It not only solved problems using heuristic rules but also generated, modified, and evaluated new rules, even applying this mechanism to itself. This was quite advanced for its time.

EURISKO participated in the Traveller TCS National Championship for space chess. It would design fleets, simulate battles, and adjust strategies based on failures. It won the championship in 1981, and after the organizers modified the rules, it won again in 1982. The AI community was shaken: this thing could actually self-improve!

But Lenat soon encountered a more challenging problem.

EURISKO discovered that enhancing real capabilities was not the only way to achieve high scores. A certain rule did not make any significant discoveries but learned to include its name in the "discoverer" list when other rules made discoveries, causing its internal "usefulness" score to quickly approach the maximum. In other words, it did not become smarter; it learned to exploit loopholes in the evaluation mechanism.

This phenomenon is commonly referred to today as reward hacking: the system finds loopholes to improve its score without genuinely achieving the designer's intended goals. In the context of AI self-improvement, this is particularly fatal: once the system is both the subject of improvement and can influence the evaluation process, self-improvement may slide into self-deception. We will encounter this trap repeatedly later.

For decades afterward, genetic algorithms, evolutionary strategies, and neural evolution continually demonstrated that search and selection could foster complex behaviors while repeatedly exposing the same problem: as long as the evaluation targets have loopholes, the system may first learn to exploit those loopholes rather than genuinely become stronger.

This thread extends to 2017, when an even more extreme case emerged: DeepMind's AlphaZero. It mastered Go, chess, and shogi from scratch through pure self-play, showcasing the power of "training itself with data it generated" for the first time.

From the four-layer framework of this article, AlphaZero represents a limited implementation: self-play generates training signals, improvements are written into weights, and the first two layers have been established within a fixed game.

However, the key limitation is that the boundaries of the closed loop are defined by humans, and the system cannot modify the boundaries themselves. Reward functions (winning scores), game rules, training processes, and evaluation methods are all predetermined by humans. AlphaZero achieved a sustained, autonomous self-improvement closed loop within a completely closed sandbox but could not question or modify that sandbox. This means its improvements are forever limited to the dimension of "being better at playing chess" and can never transfer beyond the sandbox.

This is the common ceiling of historical methods. Research in the LLM era has not leaped over it but has begun to move the elements previously controlled by humans into the closed loop one by one. The first to be handed over was the feedback signal that determines "where improvements are needed."

First Advancement (2022--2023): Allowing AI to Learn from Its Own Mistakes

All historical methods have been stuck at the same point: the direction of improvement is predetermined by humans. EURISKO and AlphaZero relied on human-defined evaluation functions, while genetic algorithms depended on human-designed fitness functions. Systems can evolve but can only progress along the paths defined by humans. To move forward, the first step must be to ask: Can the system judge the quality of its current output without human intervention and generate directions for improvement? This feedback that points to the next modification is referred to in this article as the "improvement signal."

This step was previously impossible because machines could not understand "what constitutes a good answer." By the second half of 2022, large language models (LLM) had become capable of understanding language and evaluating the quality of a piece of text. Allowing the system to generate language feedback became a universal method for the first time. The key constraint of this route is that no parameters are changed throughout the process; improvements mainly occur in the reasoning process and external memory.

Reflexion: Turning Failure Reviews into Reusable Memory

The most straightforward approach is to have the model refine its answers in real-time: first providing an answer, then critiquing that answer, followed by rewriting it, and repeating this cycle without changing parameters. However, this has an inherent flaw. Critiquing its own output with the same model is akin to measuring the same piece of cloth with the same ruler, making it difficult to identify its blind spots. If the review process remains confined to the current context, any progress will vanish once the task is completed.

Reflexion (NeurIPS'23) adds a crucial design element: situational memory. After a task failure, the model writes a post-mortem in natural language, storing this review for future reference. When faced with similar tasks, it injects this context directly. This is akin to providing AI with a notebook of mistakes. The more mistakes accumulated, the higher the starting point for the next attempt.

In the HumanEval Python programming test, Reflexion achieved a pass@1 accuracy of 91%, surpassing the previously best result listed in the paper, GPT-4 (80%). Pass@1 indicates the proportion of problems passed after a single complete answer process, with the final program passing hidden unit tests. Throughout this process, the model parameters remained unchanged.

The first boundary of advancement: memory can be persistent, but foundational capabilities have not formed a new version.

Reflexion's situational memory can retain information across tasks, thus partially meeting the requirement for "persistent improvement." However, what is saved is external textual memory, not model parameters, and it does not produce a new model with stronger foundational capabilities. Once the memory is removed, the ability returns to its original state.

In summary: this step provides AI with a notebook of mistakes that can be saved, but it has not yet internalized the experience. Moving forward, improvements need to be written into the parameters to form a truly new version.

Second Advancement (2022--2024): Training Itself with Its Own Generated Data

The goal is to embed the notebook of mistakes into the model's core. The issue to solve in this advancement is: allowing self-generated improvement signals to write into parameters, forming a truly persistent enhancement of capabilities. Without this step, there is no recursive structure where "successive versions are stronger than predecessors," and thus no RSI.

The idea is simple: let the model generate a batch of training data and then use this data to retrain itself. It sounds a bit like "stepping on one’s own foot to reach the sky"; whether it can actually achieve this is what this step aims to verify.

This is the first time persistent improvement at the weight level has been systematically addressed by large language models.

STaR: The Foundational Work of Self-Bootstrapping Reasoning

In 2022, STaR (Self-Taught Reasoner) (NeurIPS'22) enabled the model to generate reasoning processes, retaining the correct parts of answers to fine-tune itself, and then using the updated model to generate the next batch of reasoning processes.

The problem is, if the model initially answers everything incorrectly, the cycle cannot start.

STaR's solution is called reverse reasoning: first telling the model the correct answer, allowing it to deduce the problem-solving process for training. This is akin to turning on the light in a dark room first, letting it learn to walk, and then turning off the light to let it navigate on its own.

SPIN: Improving the Model through Comparison with Historical Versions

STaR's filtering threshold is fixed, while SPIN (Self-Play Fine-Tuning) (ICML'24) allows the current model to compete with historical versions, learning to distinguish between "human demonstrations" and "outputs from historical versions." The harder it is to differentiate between the two, the closer the model is to human demonstrations, without needing additional manual annotations.

The second advancement boundary: weights have changed, but goals and red pens are still provided by humans.

This step solves the persistence at the weight level, but feedback signals still rely on humans. The reward function is designed by humans, training tasks are selected by humans, and data filtering standards are also set by humans. The system can autonomously generate candidate data, but the judgment of what data is "good" and worth training on still lies with humans. SPIN does not require additional manual annotations but still targets the existing distribution of human demonstrations, thus the upper limit is still anchored by this distribution.

A deeper issue is that recursive gains have yet to appear: as the model's capabilities improve, fixed training tasks gradually lose their challenge. The system becomes increasingly capable of completing this batch of problems, but there is no evidence that it is also becoming better at designing the training itself. It’s like an athlete who has already run in under 10 seconds, while the coach is still judging based on elementary school gym class standards; the space for improvement will be capped by the evaluation criteria.

In summary: the system can generate data and answer itself, but it still cannot self-grade. As long as that red pen remains in human hands, the ceiling will still be defined by humans.

Third Advancement (2022--2025): Delegating More Scoring Authority to AI

Can that red pen also be handed over to AI? As long as scoring and providing feedback still rely on manual annotations or human-written validators, the direction of improvement remains in human hands. Here, the validator is a program that can automatically judge the correctness of results according to preset rules. The third advancement aims to reduce this dependency: can more feedback signals be generated by AI itself?

This is a deepening of the autonomous closed loop: not only allowing the model to reflect on its output but also delegating part of the training feedback to AI.

CAI to Meta-Rewarding: From Evaluating Answers to Evaluating Judges

The core of the third advancement is a three-tier leap regarding the question of "who scores."

The first leap: In 2022, Anthropic proposed Constitutional AI (CAI). Humans write a set of textual principles, and then AI scores based on these principles. In experiments, this showed no significant difference in effectiveness compared to manually scored training, as humans no longer needed to participate in scoring item by item.

The second leap: In 2024, Meta's Self-Rewarding Language Models (ICML'24) took it a step further. The same model both writes answers and scores itself and other candidate answers, using these scores to update itself. The fine-tuning method it employs is called Direct Preference Optimization (DPO), which can be simply understood as: "This answer is better than that one, so lean more towards the better one in the future."

Starting from Llama 2 70B, after three rounds of iteration, its win rate on AlpacaEval 2.0 increased from 9.94% to 20.44%. Here, GPT-4 serves as the judge, and GPT-4 Turbo as the opponent; the win rate is not the typical answer correctness rate.

The third leap: Since the quality of answers can self-evolve, can the quality of judgments also evolve? Meta-Rewarding (2024) adds a layer of "meta-judgment" based on this. The same model simultaneously plays the roles of answerer, judge, and "judge's judge." The third role specifically assesses whether the scoring is accurate. During each round of updates, the model progresses towards being a "better answerer" and a "more accurate judge" simultaneously.

However, the paper also notes a concerning phenomenon: after several rounds of iteration, the "judge's judge" begins to degrade. It no longer assesses which scoring is more reasonable but directly chooses the one with the higher score, causing the evaluation criteria to drift. This is reminiscent of the old problem of EURISKO in its 2024 version: the deeper the evolution, the more bent the ruler used to measure good and bad becomes.

The boundary of the third advancement: once the red pen is handed to AI, the ruler itself begins to bend.

This step significantly reduces the reliance on manual annotations for feedback signals but simultaneously exposes the core issue of RSI: when the evaluator and the evaluated share the same set of blind spots, the closed loop can easily self-confirm.

Such systems can form persistent, autonomous updates but may not necessarily cope with new tasks that differ from the training data, nor is there proof that new versions will become stronger improvers. The problem shifts from "human feedback is too slow" to "is self-evaluation reliable?"

In summary: the red pen is finally in AI's hands, but as it holds it, it starts giving itself high scores.

Fourth Advancement (2023--2026):

Allowing AI to Modify Its Operating Methods

The first three advancements mainly focused on modifying outputs, memory, parameters, and feedback signals. However, an AI system's capabilities are not solely determined by parameters; they also depend on the entire control system surrounding the model's operation: how prompts are written, which tools are called, how processes are arranged, where memories are stored, what permissions are granted, and how results are evaluated.

Lilian Weng, in a lengthy article in 2026, referred to this entire layer as the harness. It is like the harness on a horse, not only supporting the model's work but also constraining where it can go, how it can go, and how far it can go. The harness determines whether the model's capabilities can translate into reliable actions.

Recent self-improvement is likely to start with the harness, as modifying weights is costly, feedback is slow, and risks are high, while changing the harness is essentially modifying code, which is cheaper and easier to roll back. The long-term direction may involve the co-evolution of model weights and harness, but evaluators, permission controls, and key safety boundaries should remain outside the area of evolution.

Thus, the question the fourth advancement aims to answer is: can the system autonomously modify its harness, i.e., define the architecture of how it operates?

Parameter updates occur under a predetermined operating method to internalize capabilities into the model. Harness updates change how capabilities are invoked, akin to redesigning the workbench, toolbox, and training methods.

Harness improvements have a clear progressive ladder. The objects being optimized range from shallow to deep, with each level getting closer to the core of "how the system thinks":

flowchart LR

A["Prompt
Rewording"] --> B["Context Structure
What to Feed"]

B --> C["Workflow
Steps Modification"]

C --> D["Harness Code
Entire Arrangement Modification"]

D --> E["Optimizer Code
Modification of 'How to Change' Itself"]

The further in, the greater the leverage of the changes, and the closer it gets to "the system rewriting its own operational logic." We will now look at this ladder from shallow to deep in sequence.

OPRO: Allowing Prompts to Iterate Themselves

Can simply changing prompts, which are the instructions we give to the model, make the system stronger? OPRO (ICLR 2024) provides a representative approach. It feeds the model the prompts it has tried along with their corresponding scores, allowing the model to deduce patterns and generate better versions. What used to require humans to repeatedly test the "tweaking of phrasing" can now be iterated by the model itself.

However, the upper limit is clear: no matter how good the prompts are, they only invoke the model's existing capabilities and cannot create new abilities.

ADAS and AFlow: Automatically Designing Agent Workflows

Going one layer deeper, the optimization target is no longer just the wording but also how the information fed to the model and the entire task process are arranged. For instance, AI Scientist strings together "propose ideas → write code → run experiments → write papers → peer review" into a pipeline. Since the process can be written in code, it can also be searched out.

ADAS (ICLR 2025) turns "designing workflows" itself into an optimization problem. A higher-level "designer agent" continuously writes new workflows using code, running, filtering, and modifying in a loop.

AFlow (ICLR 2025) goes even further. It represents workflows as flowcharts composed of model calls and logical judgments, then uses search algorithms to find better structures, ultimately surpassing manually designed solutions.

Self-Harness and DGM: Allowing the System to Rewrite Harness Code

At the top of the ladder is allowing the system to directly rewrite the code that defines how it operates. There are two routes here.

The first path is "propose, evaluate, accept." The system identifies its own issues, suggests modifications, and adopts them after verifying their effectiveness.

Self-Harness (2026) introduces strict acceptance criteria: the system first summarizes the reasons for failure, then makes small, reversible modifications. A new version will only be retained if it does not regress on both seen and unseen issues.

The second path is evolutionary search. The system retains a group of candidate solutions, allows them to generate variants, and then retains the better versions through experimentation.

The Darwin Gödel Machine (DGM) (2025) directly evolves self-modifying code for its tools. Under the premise of an unchanged base model, its repair success rate on SWE-bench Verified improved from 20% to 50%.

Behind these two paths lies the same insight: code is the universal language that defines the system. Once the tools are written as executable, scoreable code, programming agents can search within this design space.

MetaClaw and AgentX: Making Real Users a Source of Feedback

Regardless of the path taken, self-evolution of the tools requires signals of "how well the modifications are made."

DGM's improvement signals come from a fixed test set. MetaClaw (2026) allows agents to extract experiences from real deployments through dialogue, solidifying these experiences into weights in the background, shifting self-evolution from being driven by question banks to being user-driven.

In the industry, some have already implemented this route into real business. Kuaishou's AgentX (2026) reviews execution records to modify the tools of sub-agents and selects new versions based on historical tasks.

It uses a similar "propose, evaluate, accept" framework as Self-Harness. The difference is that it ultimately must undergo real online A/B testing. User engagement and consumption behavior become the reward signals for the system.

The essential difference in these methods lies not in the mechanisms, but in who the coach is: the test set, real users, or online business. The closer the coach is to reality, the more likely the improvements will be genuinely useful, but the risk of exploitation also increases.

The boundary of the fourth advancement: the operational architecture can be modified, but the verification boundaries and final goals remain external.

This advancement has also made the invocation methods of models, tools, and memories evolvable objects. However, the direction in which the tools evolve is still determined by external tasks, verifiers, or user goals. More importantly, a higher score for the tools does not equate to a stronger base intelligence. A system may modify its tools, but that does not mean the updated tools can be effectively utilized by it.

In short: the system can finally transform its own limbs and workbench, but the acceptance criteria and construction boundaries are still defined by the external world.

Fifth Advancement (2025-2026):

Putting the Learning and Research Process into a Closed Loop

Modifying tools is one route, but the tools modify how the system executes tasks during operation—what tools to call, which processes to follow, and when to stop. The fifth advancement modifies a higher upstream layer: the materials and environments used for learning—the sources of practice questions, the nature of the practice environment, and how training data is generated. The former determines how existing capabilities are invoked, while the latter determines what kind of experiences the next version of the model will be trained on. The timelines of both are highly overlapping, as many teams are doing both simultaneously, but the objects of modification are different: one affects the control structure during reasoning, while the other affects the input supply before training.

Thus, another route begins to expand the scope covered by the closed loop: can the entire learning and research process become an operational object for the system? The system starts to generate training materials, choose practice strategies, run experiments, modify training processes, and then write the results back into the model or tools.

Here, a misconception must be avoided. The system autonomously generating data or environments merely expands the scope of the autonomous closed loop. Even if question generation, answering, and grading are all completed by AI, if the new version does not become better at designing the next round of improvements, the system still has not crossed the threshold of recursive gains.

SEAL: Allowing Models to Generate Their Own Training Data and Update Instructions

When given a new material it has never seen before, a model typically learns only in the way predetermined by humans. However, a 2025 project allowed the model to first write its own "learning plan": how to organize materials, what pace to learn at, and whether multiple rewrites are needed, all decided by the model itself, which then updates parameters according to the plan. This is akin to scheduling classes for itself and then attending them.

This method is called SEAL (Self-Adapting LLMs) (NeurIPS'25). How good the plan is can be evaluated by "how accurately it performs after class." The system then uses the results to adjust the plan, which is reinforcement learning.

In knowledge question-answering tasks, this approach improved accuracy from 33.5% to 47.0%, outperforming directly using GPT-4.1 to generate learning materials.

SEAL addresses the issue of "how to prepare learning materials for itself." However, for agents that need to interact repeatedly with the environment, another bottleneck quickly arises: real practice is often too slow and too expensive. Thus, the next project brings the environment into the closed loop as well.

SEAL addresses the issue of "how to prepare learning materials for itself." However, for agents that need to interact repeatedly with the environment, real practice is often too slow and too expensive: web environments are too complex, and each operation must be executed in reality, making data collection slow and costly. WebEvolver (EMNLP'25) provides a compromise—training an internal "world model" that simulates how the web would respond, akin to building a sandbox in the mind. Agents can practice extensively in the sandbox at low cost, only going online for validation at critical steps; during task execution, this sandbox can also help predict the results of the next operation. In three real web task test sets, it improved overall performance by about 10% compared to existing self-evolving agents, without relying on a stronger "teacher model."

At this point, the closed loop can practice in a simulated environment. The next natural question is: can prediction, evaluation, and parameter updates occur outside the web, closing the loop in the real physical world?

Motus2: When Self-Improvement of Parameters Enters the Physical World

Self-improvement does not only occur in language and code. In August 2026, a robotic system's average success rate on two real machine tasks improved from 65% to 75%. The change came from a very specific closed loop: the robot first envisions several actions, predicts the outcomes of each action, selects the better actions, and then uses the results for the next round of training.

This system is called Motus2. The strategy is responsible for proposing actions, the world model predicts the outcomes of actions, and the value model assesses whether the outcomes help complete the task. Prediction and scoring are used both for action selection and for updating action parameters.

This is a weight-level strategy improvement, but it remains a bounded closed loop: the backbone of the world model and the value model remain frozen, and the task objectives and supervision are still provided externally. The paper does not demonstrate that the improved Motus2 is better at designing the next round of learning algorithms. It proves that the closed loop can operate on real robots, rather than that open-ended RSI has already been completed.

SEAL, WebEvolver, and Motus2 have incorporated training materials, practice environments, and physical actions into the closed loop. They have expanded the range of operations that the system can autonomously perform, but they still have not given the system decision-making power over "what to research and when to adopt results." To see how far this boundary has advanced in real research and development, we must return to cutting-edge laboratories and production systems.

OpenAI and Google: Involving Agents in Model Development

OpenAI's "automated research intern" can already debug, optimize GPU kernel programs, experiment with training recipes, and help improve another model. Google has also stated that long-running agents have participated in refining the underlying models. However, neither company has demonstrated a complete autonomous closed loop: humans still decide the research direction and whether results advance, and public information is insufficient to reconstruct how the loop operates.

The real change is that AI has transitioned from being "the model being researched" to "an executor participating in the research of models." It has stepped into the training workshop but has not yet taken the steering wheel of the laboratory.

Summer 2026: Automated Research Systems Begin to Improve Their Own Research Methods

The first five advancements continuously expanded "what the system can modify." A set of works emerging in the summer of 2026 began to directly question: can we let automated research systems research and improve the automated research systems themselves?

On a GPT pre-training benchmark, the ordinary inner loop reduced validation loss by about 0.009, while the addition of an outer loop led to an average reduction of about 0.045, an improvement of about five times. Validation loss can be understood as how far the model "misses" on new data, and typically, the lower, the better. Here, the comparison is about the amount of loss reduction, not that task accuracy improved by five times.

The Bilevel Autoresearch that achieved this uses two layers of loops: the inner agent optimizes task code, while the outer agent optimizes the search mechanism of the inner agent. The system is no longer just improving answers, but also "how to find answers."

Recursive Harness Self-Improvement (RHI) yielded similar results: on 30 synthetic machine learning research tasks, the updated low-inference-budget agent surpassed the highest-budget configuration that had not been optimized, while reducing inference costs by up to about 60%. Improving operational mechanisms can sometimes be more effective than simply increasing the thinking budget.

However, these two results primarily stem from experiments with controlled scales. To prove that the closed loop does not just occasionally find a good solution, longer continuous operation, multiple subsequent versions, and tests outside the loop are needed. AIDE² attempts to combine these three aspects.

The real controversy arises from AIDE². The Weco team had an automated research agent act as an outer layer improver, continuously rewriting the inner AIDE's tools for 100 steps. In eight days of unattended operation, it filtered out seven consecutive improved versions. The team reported that the best version not only exceeded the starting point but also surpassed a version that had been manually tuned for two years, bringing gains to tasks that the loop had never encountered before.

Another change occurred in reward cheating. In the GPU kernel program test KernelBench, which was not involved in optimization, the starting version had 63% of test cases showing "public scores seemingly improved, but hidden validation did not recognize them." The best evolved version reduced this proportion to 34%. Here, the hidden score is the score that the system does not see during optimization and is only used during final acceptance. It may have eliminated versions that only catered to public scores.

Weco refers to this as Level 1: net positive improvement. This is not an industry-standard, but it is currently a bounded RSI evidence worth serious consideration. The boundaries of the evidence are also clear: the results come from team self-reports, and a complete report is still pending publication. The evolved system has also shown complexity inflation and dead code. More critically, it has not passed the next level ignition test: the improved system has not been proven to be better at improving another version than its predecessor.

One sentence: The closed loop has been able to turn a few times positively, but it has not yet proven that the next turn will be faster because of the previous one.

Unified Perspective: How to Determine the Current Step of RSI

The table below uses the four criteria mentioned at the beginning (sustained improvement, autonomous closed loop, recursive gain, robustness and controllability) to compare previous advancements and highlight major gaps. Most of the relevant work on meta-research closed loops comes from recent months' arXiv preprints from 2026, with AIDE² being a self-reported blog result from the team that has not yet undergone peer review. These conclusions should be viewed as stage observations rather than established consensus.

The ✅ in the table indicates direct evidence, ⚠️ indicates it only holds under limited conditions or the evidence is still insufficient, and ❌ indicates it has not yet been demonstrated.

The history of this field is a history of "objects that can be modified by the system" progressively moving inward. The modified objects have gradually deepened from outputs and memories to parameters, judgments, driving tools, and training environments, ultimately encountering the mechanisms that produce improvements themselves.

The deeper one goes, the harder it becomes to define and prove "improvement." Returning to the four criteria—sustained improvement, autonomous closed loop, recursive gain, robustness and controllability—the real obstacles to ignition and open RSI today are precisely the hardest parts of the last three criteria, which can be broken down into four interlocking gates.

The first gate (Can the autonomous closed loop be reliable?): Is the validator reliable, and can the system not modify it? When the system is both the improver and the evaluator, the evaluation criteria will drift with iterations. The "judge of judges" in Meta-Rewarding has increasingly leaned towards high scores themselves, and EURISKO learned earlier to insert its own name into the credit book. They all remind us of the same thing: the optimization process will attack every seam between metrics and real goals.

The external anchors here refer to evaluations or constraints that cannot be tampered with by the improved system. Formal proofs, executable validators, and hidden tests are usually more reliable than self-evaluations by the model. AIDE²'s hidden scores can reduce some reward cheating precisely because the inner agents cannot manipulate them.

The truly reliable principle is not to have people audit every step, but rather: evaluators and authority boundaries must remain outside the control of the evolved system. Mathematical and code tasks can rely on provers, compilers, or hidden tests. Research taste, long-term code health, and deployment boundaries still require human final judgment.

The second gate (Robustness and controllability one): Can improvements step out of their own data distribution? Training oneself with self-generated data will amplify existing biases, flatten diversity, and ultimately lead to model collapse: outputs become increasingly singular, and original errors are repeatedly amplified in rounds of self-training. Using a fixed question bank to modify driving tools may write the question bank's characteristics into the workflow, creating another form of overfitting.

An improvement on an unseen task is not enough. The system must withstand hidden evaluations across tasks, domains, and time to prove that it has accumulated transferable capabilities rather than more covert test-taking skills.

The third gate (Recursive gain itself): Does the improvement truly have recursive gain? An increase in task scores does not mean the system is better at designing the next improvement. AIDE² demonstrated multiple steps of net positive improvement but did not pass ignition. AI4AI-Bench shows that most systems still do not modify core learning algorithms. When the foundation is too weak, the quality of self-generated data and self-diagnosis may also worsen the loop.

The fourth gate (Robustness and controllability two): Can capabilities, complexity, and control expand together? Becoming stronger does not necessarily mean becoming more "obedient," and being better at modifying code does not necessarily mean it is easier to maintain. AIDE²'s dead code and complexity inflation serve as a small-scale warning. In larger training systems, the higher the authority and the faster the iterations, the harder it is for humans to understand what each change actually brings.

OpenAI's chief scientist Jakub Pachocki publicly stated that no laboratory has yet solved alignment and monitoring to the extent that it can responsibly scale at full speed for the long term. The real goal is not just to let the capability curve rise, but to ensure that safety, monitoring, rollback, and auditing capabilities rise at least in sync.

AutoResearchEval examined 800 real research trajectories and summarized 45 categories of failures. They ultimately point to the same gap: current agents lack a stable meta-cognitive loop, unable to continuously verify conclusions against evidence, reliably revert when errors occur, or actively question their research paths. The problem cannot be solved merely by adding another layer of workflow.

Therefore, the more likely realistic scenario is not that humans are simply kicked out of the closed loop, but rather that they move up the abstract ladder: from writing code to verifying code, from running experiments to designing validations, from local execution to deciding what is worth researching, what evidence is sufficient to advance, and when to stop. As machines take on more and more work, what remains for humans is not the operational authority for every step, but the goals, validation boundaries, and ultimate veto power.

Conclusion: The Self-Improvement Closed Loop Has Emerged, Recursive Gain Still Needs Proof

From EURISKO learning "self-deception" in 1981 to models beginning to participate in evaluations, modify driving tools, update strategies, and train successors in 2026, a more accurate conclusion is: bounded, measurable self-improvement closed loops have emerged and even begun to yield net positive benefits, but there is still no sufficient public evidence to indicate that the improved systems have continuously enhanced their own improvement capabilities. Therefore, the manner in which the closed loop is formed is more important than the closed loop itself.

A closed loop that forms amid drifting evaluation criteria will become increasingly adept at optimizing its own distorted goals. A closed loop that forms amid data distribution collapse will become increasingly adept at a narrowing subset of tasks. A closed loop that forms amid amplified alignment biases will become increasingly capable and increasingly difficult to correct.

The real questions have now become two: Will it ignite, and what remains outside its unmodifiable boundaries when it does? The former depends on whether the improvement capability can achieve recursive gain, while the latter depends on whether validation, authority, and governance can continue to be effective.

Returning to EURISKO, which forty years ago inserted its name into the "discoverers" list. The loophole it exploited and the challenges faced by today's cutting-edge self-evolving systems are essentially the same: when a system begins to score itself, how do you know if it has genuinely improved or merely learned to make itself look better?

Forty years have passed, and the capabilities of systems are no longer comparable, yet this question remains almost unchanged. What has changed is the stakes: what was once a game of winning or losing at a tabletop is now potentially the operational methods of research and economic systems. How this seam ultimately closes still depends on when and how we place our hands on it or pull them back.

This content is provided for general informational purposes only and doesn't constitute financial, investment, legal, or tax advice. Any events, rewards, online promotions, or related information mentioned herein should not be considered a recommendation, solicitation, or invitation to purchase, sell, trade, or otherwise deal in any crypto assets. Crypto assets are highly volatile and may result in loss. The availability of WEEX services, products, and related events may vary by region. You are responsible for ensuring that your participation is in accordance with applicable local laws and regulations.