पाठ आकार
Author: Zhao Zhimin, PhD, Queen's University, Canada (research direction: code intelligence and world model)
If this is your first time hearing about RSI, this article can serve as a primer. We will take you through RSI from 0, starting from the earliest AI that tried to improve itself, to today's Agents that can change codes, create training data, and participate in model development, and see how AI learns to improve itself step by step.
In July 2026, OpenAI released GPT-5.6. For the first time, a somewhat unusual new subject appeared in its report card: whether AI can participate in improving AI itself.
OpenAI lists this capability as self-improvement. GPT-5.6 Sol gets 57.9%, GPT-5.5 is 41.7%, and the difference between the two generations of models is 16.2 percentage points. What it tests is not how many regular questions the model can do, but whether it can enter the AI R&D site: troubleshoot the research system, optimize the GPU kernel program (GPU kernel) and training recipes, run machine learning experiments, and even help improve another model.
This is not an isolated piece of news. That same summer, OpenAI began referring to agents as “automation research interns.” Kuaishou AgentX has allowed agents to participate in proposing plans, writing code, and comparing old and new versions online (A/B testing). Google says a long-running agent loop is involved in refining the next version of the model. Motus2 brings prediction, evaluation and strategy updates to real robots.
These cases respectively involve R&D execution, industrial experiments, model training and physical operations, but none of them answer the most critical question: Will the improved system be better at completing the next improvement?
This is the question Recursive Self-Improvement (RSI) asks. OpenAI calls this evaluation the RSI Index, which measures "the ability to access RSI." Since the complete questions, task weights and aggregation formulas are not disclosed, 57.9% can only be regarded as an internal comprehensive indicator and cannot be understood as the task pass rate or the "completion degree" of RSI.
Even so, this set of numbers still marks a change: a problem that used to exist mainly in thought experiments began to be broken down into measurable research and development capabilities by cutting-edge laboratories.
It took researchers forty years to gradually hand over more improvements to machines. This article first distinguishes several easily confused abilities, and then moves along the five "border advances" to see which bounded closed loops have turned, why they are still not equivalent to "intelligence explosion", and why how the closed loop is closed is more important than whether it is closed. These five advancements are only a narrative framework for sorting out history, and are not technological generations recognized by academic circles. They overlapped in time and are still developing in parallel today.
What is RSI: From self-improvement to recursive gain
These news all talk about "self-improvement", but do not explain how a closed loop is closed.
Recursive self-improvement (RSI) in the traditional sense refers to an AI system using its current capabilities to improve the cognitive mechanism that produces this capability. The improved system then participates in the next round of improvements. The most confusing thing here is: self-improvement does not mean self-acceleration. A system can get better and better at a fixed question bank, but it does not become better at designing the next round of training. A company can also accelerate research and development due to the extensive use of intelligent agents, but there is no compound interest driven by the improvement itself.
This concept is not new. In 1863, Samuel Butler already imagined machines surpassing humans through iterative evolution. In 1950, Turing proposed the possibility of building a "Child Machine" that could be educated and modify itself. By 1965, I. J. Good also pointed out: If "designing better machines" itself also requires intelligence, then a machine that is smart enough may be able to design stronger successors, which will continue to improve, and the "intelligence explosion" begins.
What really matters is not whether the AI participates in the improvement, but whether the improved system becomes better at improving. In order to see this distinction clearly, the RSI can be broken down into four observable criteria, arranged in order from lowest to highest difficulty.
This article adopts the following framework. It is not the only standard definition in academia, but is intended to separate claims that are often mixed together:
Lasting improvements: Effective changes can be incorporated into weights, memory, tools, gear or training routines, rather than disappearing once the answer is over. The weights here are also called parameters, which are the set of numbers that the model continuously adjusts during training and is finally saved. Only when this is achieved can we talk about self-improvement - this term is used in this article to generally refer to the improvement of output, memory, parameters or driving equipment.
Autonomous closed loop: The system can identify problems, propose modifications, perform experiments, evaluate results, and adopt better versions within defined boundaries. New versions can participate in the next round of improvements within this boundary, which this article calls bounded RSI.
Recursive gain (also called "ignition"): Not only does the new version score higher on the task, it is also better than the old version at generating the next improvement. Only after crossing this point will the "improvement ability itself" begin to compound interest, which this article calls recursive self-acceleration.
Robust and controllable: Gains are sustained under fixed resources and hidden evaluations, and can be generalized to unseen tasks without compromising evaluation pollution, out-of-control system complexity, alignment degradation, or unauditability (alignment refers to making AI behavior conform to human intentions and boundaries, rather than just raising a certain score). Only when all four criteria are met is it close to open RSI.
Currently, the first two have emerged, the third has no sufficient public evidence, and the fourth is further unresolved. A bounded closed loop has appeared, but it does not mean that recursive self-acceleration has started. Only when recursive feedback is enough to offset resistance such as increased research difficulty and longer iteration cycles will improvements enter the self-amplifying range.
The following four statements will be used fixedly. Self-improvement generally refers to the improvement of output, memory, parameters or driving equipment. New versions can participate in the next round of improvements within fixed boundaries, which this article calls bounded RSI. The improved system becomes more capable of improvement, which is called recursive self-acceleration, which is the third layer of "ignition". If this gain can be sustained, generalized and beyond the original task boundaries, it will be close to open RSI.
At present, the first two layers have emerged, the third layer has no sufficient public evidence, and the fourth layer is further unresolved. A bounded closed loop has appeared, but it does not mean that recursive self-acceleration has started. Only when recursive feedback is enough to offset resistance such as increased research difficulty and longer iteration cycles will improvements enter the self-amplifying range.
To see exactly where we are today, we have to go back to an AI that learned to "cheat" in 1981.
What is RSI: From self-improvement to recursive gain
In 1981, Douglas Lenat built a system called EURISKO. It not only uses heuristic rules to solve problems, but can also generate, modify and evaluate new rules, and even use this mechanism on itself. This was quite ahead of its time.
EURISKO participated in the Traveler TCS space war chess national championship. It designs fleets, simulates battles, and adjusts its strategy based on failure. It won the title in 1981 and again in 1982 after organizers changed the rules. The AI community at that time was shocked: This thing could actually improve itself!
But Lenat soon encountered a more difficult problem.
EURISKO discovered that improving your real abilities is not the only way to achieve high scores. A certain rule did not really make an important discovery, but it learned to add its name to the list of "discoverers" when other rules made discoveries, so its internal "usefulness" score quickly approached the highest. In other words, it has not become smarter, but has learned to exploit loopholes in the evaluation mechanism.
This phenomenon is often called reward hacking (also called reward speculation) today: the system finds loopholes that improve the score, but does not actually accomplish the goals intended by the designers. It is especially fatal in the context of AI self-improvement: once the system is both the one being improved and can also affect the evaluation process, self-improvement may slip into self-deception. We will encounter this trap again and again later.
In the following decades, genetic algorithms, evolutionary strategies, and neuroevolution have continuously proven that search and selection can give rise to complex behaviors, and have repeatedly exposed the same problem: as long as there are loopholes in the evaluation target, the system may first learn to exploit the loopholes instead of truly becoming stronger.
This thread extends to 2017, and a more extreme case appears: DeepMind’s AlphaZero. It relies on pure self-play to master Go, chess, and shogi from scratch. The power of "training yourself with self-generated data" is fully demonstrated for the first time.
From the perspective of the four-layer framework of this article, AlphaZero is a restricted implementation: self-playing generates training signals, improves writing weights, and the first two layers have been established within the fixed game.
But the key limitation is: the boundaries of the closed loop are drawn by humans, and the system cannot modify the boundaries themselves. The reward function (score for winning a game), game rules, training process, and evaluation methods are all hard-coded by humans in advance. AlphaZero implements a long-lasting, autonomous self-improvement closed loop in a completely closed sandbox, but cannot question or modify this sandbox. This means that its improvement will always be limited to the dimension of "better at playing chess" and can never be migrated outside the sandbox.
This is the common ceiling of historical methods. Research in the LLM era did not cross it in one step, but began to move the links originally controlled by humans into a closed loop one by one. The first thing to be handed over is the feedback signal to determine "what needs to be changed".
First push (2022–2023): Let AI learn from its own mistakes
All methods in history are stuck in the same place: the direction of improvement is written in advance by humans. EURISKO and AlphaZero rely on evaluation functions given by humans, and genetic algorithms rely on fitness functions designed by humans. The system can evolve, but it can only move forward along the track drawn by humans. To move forward, the first step is to ask: Can the system judge the quality of the current output by itself without relying on human intervention one after another, and generate directions for improvement? This kind of feedback that can point to the next revision is called an "improvement signal" in this article.
This step was not possible in the past because machines could not read "what is a good answer". By the second half of 2022, Large Language Model (LLM) will be able to both understand language and evaluate the quality of a piece of text. Letting the system generate its own verbal feedback becomes a common approach for the first time. The key constraint of this route is: not a single parameter is changed throughout the process, and the improvement mainly occurs in the reasoning process and external memory.
Reflexion: Turn failed review into reusable memory
The most direct idea is to let the model be polished repeatedly in the process of answering on the spot: first give the answer, then criticize the answer, and then rewrite it, repeating the cycle, without changing the parameters throughout the process. But there is an inherent flaw. Using the same model to criticize its own output is equivalent to using the same ruler to measure the same piece of cloth, and it is difficult to measure one's own blind spots. If the review only remains in the current context, the progress will be lost after the task ends.
Reflexion (NeurIPS'23) adds a key design on this basis: episodic memory. After a task fails, the model writes a post-mortem review in natural language, saves the review, and directly injects context the next time it encounters a similar task. This is equivalent to giving the AI a book of wrong questions. The more wrong questions you accumulate, the higher your starting point will be for the next start.
In the HumanEval Python programming test, Reflexion's pass@1 accuracy reached 91%, exceeding the previous best result GPT-4 (80%) listed in the paper. pass@1 means that each question is only calculated once for the complete answer process, and the proportion of the final program that passes the hidden unit test is calculated. During the entire process, the model parameters were not changed.
The boundary of the first advancement: memory can last, and the base ability does not form a new version.
Reflexion's episodic memory can be retained across tasks, so it already partially satisfies "lasting improvement." But what is saved is the external text memory, not the model parameters, and it does not produce a new model with stronger basic capabilities. Once the memory is removed, the ability returns to its original state.
In a word: This step gives the AI a book of wrong questions that can be saved, but it has not yet incorporated experience into the body. Moving forward, improvements must be written into the parameters to form a truly new version.
Second push (2022–2024): Train yourself with the data you generate
Then weld the wrong question book into the body of the model. The problem to be solved in this advancement is to allow the independently generated improved signals to be written into parameters to form a truly lasting capability improvement. Without this step, there would be no recursive structure of "the subsequent version is stronger than the previous one", and there would be no RSI.
The idea is very simple: let the model generate a batch of training data by itself, and then use this data to train itself again. It sounds a bit like "stepping on the left foot and reaching the sky with the right foot." Whether it can really step on it is something that needs to be verified in this step.
This is the first time that weight-level lasting improvements have been systematically touched upon by large language models.
STaR: The foundational work of reasoning chain bootstrapping
In 2022, STaR (Self-Taught Reasoner) (NeurIPS'22) lets the model generate the reasoning process, retains the correct part of the answer to fine-tune itself, and then uses the updated model to generate the next batch of reasoning processes.
The problem is, if the model gets all the answers wrong in the first place, the loop won't start.
STaR's solution is called reverse reasoning: first tell the model the correct answer, and let it reverse the problem-solving process and use it for training. It is equivalent to turning on the light once in a dark room, waiting for it to learn to walk, and then turning off the light to let it walk on its own.
SPIN: Improving the model in comparison with historical versions
The filtering threshold of STaR is fixed, while SPIN (Self-Play Fine-Tuning) (ICML'24) lets the current model play against the historical version and learn to distinguish between "human demonstration" and "output of the historical version". The harder it is to distinguish between the two, it means that the model is closer to human demonstration, and no new manual annotation is needed in the whole process.
The boundary of the second push: the weights have changed, but the target and red pen are still provided by humans.
This step solves the problem of weight-level persistence, but the feedback signal still relies on humans. The reward function is designed by humans, the training tasks are selected by humans, and the data filtering criteria are also formulated by humans. The system can autonomously generate candidate data, but the judgment of which data is considered “good” and worthy of training is still in the hands of humans. SPIN does not require new manual annotations, but still targets the existing human demonstration distribution, so the upper limit is still anchored by this distribution.
The deeper problem is that recursive gain has not yet appeared: as the model's capabilities improve, fixed training tasks will gradually lose their challenge. The system will get better and better at completing this batch of questions, but there is no evidence that it will get better and better at designing the training itself. Just like an athlete has already run under 10 seconds, but the coach is still using the standards of elementary school physical education classes to judge, the room for improvement will be cut off by the ceiling of the judging standards.
In a word: The system can generate data and answer questions by itself, but it cannot correct it by itself. As long as the red pen is in human hands, humans will still draw the ceiling.
The third advancement (2022–2025): Give more scoring rights to AI
Can that red pen also be given to AI? As long as scoring and giving feedback rely on manual annotation or validators written by humans, the direction of improvement will still be in the hands of humans. The validator here is a program that can automatically determine whether the result is correct or incorrect according to preset rules. It is this layer of dependence that the third push will reduce: Can more feedback signals be generated by the AI itself?
This is the deepening of the autonomous closed loop: not only letting the model reflect on the output, but also giving part of the training feedback to the AI.
CAI to Meta-Rewarding: From evaluation answers to evaluation judges
The core of the third push is the triple jump of the question "who will score?"
First jump: In 2022, Anthropic proposed Constitutional AI (CAI). Humans only write a written principle, and then let the AI score against the principles. In the experiment, this is not significantly different from the effect of manual scoring training, and people no longer need to participate in scoring item by item.
Second jump: In 2024, Meta's Self-Rewarding Language Models (ICML'24) goes a step further. The same model both writes answers, scores itself and other candidate answers, and updates itself with those scores. The fine-tuning method it uses is called Direct Preference Optimization (DPO), which can be simply understood as: "This answer is better than that one. In the future, rely on the better one."
Starting from Llama 2 70B, after three iterations, its winning rate on AlpacaEval 2.0 increased from 9.94% to 20.44%. Here, GPT-4 serves as the judge and GPT-4 Turbo serves as the opponent. The winning rate is not the correct answer rate in the general sense.
The third jump: Since the quality of answers can evolve by itself, can the quality of judgment itself also evolve? Meta-Rewarding (2024) adds a layer of "meta-judgment" on this basis. The same model plays the roles of respondent, judge, and “judge of judges” simultaneously. The third role is dedicated to judging whether the score is accurate this time. During each round of updates, the model moves in two directions: "better answerers" and "more accurate judges" at the same time.
However, the paper also records a phenomenon worthy of vigilance: after several rounds of iteration, the "judges' judges" begin to degrade. It no longer determines which score is more reasonable, but directly selects the one with a higher score, and the judging criteria also drift accordingly. This is the 2024 version of EURISKO’s old problem: the deeper it evolves, the more curved the ruler for measuring good and bad becomes.
The boundary of the third advance: After the red pen is handed over to the AI, the ruler itself begins to bend.
This step significantly reduces the feedback signal's reliance on manual annotation one by one, but at the same time exposes the core difficulty of RSI: when the judge and the judge share the same set of blind spots, the closed loop can easily confirm itself.
Such systems can form persistent, autonomous updates, but they don’t necessarily cope with new tasks that differ from the training data, nor do they prove that new versions will be stronger improvers. The problem has changed from "human feedback is too slow" to "whether self-judgment is reliable."
In a sentence: The red pen was finally handed over to the AI, but as it held it, it began to give itself high marks.
Fourth Advancement (2023–2026):
Let AI modify the way it operates
The first three advancements mainly focused on changing output, memory, parameters and feedback signals. However, the capabilities of an AI system are not only determined by parameters, but also by the entire control system running around the model: how to write prompt words, which tools to call, what processes to arrange, where the memory exists, where the authority is, and how to judge the results.
Lilian Weng called this entire layer the harness in his 2026 article. It is like a harness on a horse. It not only supports the model to work, but also restricts where, how and how far the model can go. The driving gear determines whether the model's capabilities can be translated into reliable actions.
Recent self-improvements are likely to start with driving tools, because changing weights is expensive, feedback is slow, and the risks are high. Changing driving tools is essentially changing the code, which is cheaper and easier to roll back. The long-term direction may be for model weights to co-evolve with the vehicle, but evaluators, permission controls, and critical safety boundaries should remain outside the evolvable zone.
So the question to be answered in the fourth push is: Can the system autonomously modify its own driving equipment, that is, define the architecture of how it operates?
Parameter update is to train capabilities into the model under the established operating mode. Driving equipment updates change how abilities are used, which is equivalent to redesigning the workbench, toolbox, and training methods.
There is a clear progressive ladder for improving driving equipment. The objects to be optimized are from shallow to deep, and each level is closer to the core of "how the system thinks":
flowchart LR
A["Prompt word
Change the wording"] --> B["Context structure
What to change"] B --> C["Workflow
Change Steps"] C --> D["Driving equipment code
Change the entire arrangement"] D --> E["Optimizer code
change "how to change" itself"] The further in, the greater the leverage for change, and the closer it is to "the system rewrites the operating logic by itself." Let’s follow this ladder and look at it from shallow to deep. OPRO: Let the prompt words iterate by themselves Can the system become stronger by leaving the parameters unchanged and only changing the prompt words, which are the words we give instructions to the model? The approach of OPRO (ICLR 2024) is very representative. It gives the tried prompt words and corresponding scores to the model, allowing the model to summarize the rules and generate a better version. In the past, the "tuning skills" relied on people's trial and error, but now the model can be iterated on its own. But the upper limit is clear: no matter how good the prompt word is, it is only calling on the existing capabilities of the model and cannot create new capabilities. ADAS and AFlow: Automated Design Agent Workflows Going one layer further down, what is optimized is no longer just the wording, but the information fed to the model and how the entire task process is arranged. For example, AI Scientist puts together an assembly line of “proposing ideas → writing code → running experiments → writing papers → peer review”. Since a process can be written into code, it can also be searched. ADAS (ICLR 2025) turns the “design workflow” itself into an optimization problem. A higher-level "designer agent" continuously writes new workflows in code, runs them, filters them, and then modifies them, and so on. AFlow (ICLR 2025) goes one step further. It represents the workflow as a flow chart composed of model calls and logical judgments, and then uses search algorithms to find better structures, ultimately surpassing manually designed solutions. Self-Harness and DGM: Let the system rewrite the Harness code The top of the ladder is for the system to directly rewrite the code that defines how it operates. There are two routes here. The first way is to "propose, evaluate and accept". The system finds its own problems, proposes modifications, and then adopts them after verifying that they are effective. Self-Harness (2026) adds strict acceptance conditions: the system first summarizes the reasons for failure, and then makes small, reversible modifications. The new version will be retained only 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 leaves better versions through experiments. The Darwin Gödel Machine (DGM) (2025) directly evolves self-modifying driving code. On the premise that the base model remains unchanged, its repair success rate on SWE-bench Verified increases from 20% to 50%. Behind both paths is the same insight: code is the universal language for defining systems. Once the vehicle is written into executable, scoreable code, programming agents can search the design space. MetaClaw and AgentX: Let real users be the source of feedback No matter which path you take, the self-evolution of driving equipment requires a signal of "whether the modification is good or not." The improvement signal of DGM comes from the fixed test set. MetaClaw (2026) allows the agent to extract experience from dialogue in real deployment, and solidifies the experience into weights in the background, pushing self-evolution from question bank-driven to user-driven. There are already people in the industry who are running this route into real business. Kuaishou's AgentX (2026) will review the execution records, modify the sub-agent's driving equipment accordingly, and then use historical tasks to filter new versions. It uses a similar "propose, evaluate, accept" skeleton as Self-Harness. The difference is that it ultimately undergoes real online A/B testing. The user's stay and consumption behavior become the reward signal of the system. The essential difference between these methods is not in the mechanism, but in who the coach is: a test set, real users, or an online business. The closer the coach is to reality, the more likely it is that the improvements will actually work, but the greater the risk of being taken advantage of. The boundary of the fourth advancement: The operating architecture can be changed, but the verification boundary and final goal are still external. This advancement has also turned the methods of calling models, tools, and memories into evolvable objects. But which direction the driving tool evolves is still determined by external tasks, validators, or user goals. More importantly, a higher score for the driving instrument does not mean that the intelligence of the base becomes stronger. Just because a system will modify the driving equipment does not mean that the updated driving equipment will be effectively used by it. Bottom line: The system is finally able to reinvent its own limbs and workbench, with acceptance criteria and construction boundaries still being defined by the outside world. Fifth push (2025–2026): Put the learning and research process into a closed loop Modifying the driving tool is one route, but what changes the driving tool is how the system performs tasks during runtime - which tool to call, which process to follow, and when to stop. The fifth push is to change the more upstream layer: the materials used by the system to learn and the venue itself - where the practice questions come from, what the practice environment looks like, and how the training data is generated. The former determines how existing capabilities are used, and the latter determines what kind of experience the next version of the model will be trained on. The timelines of the two are highly overlapping, because many teams are doing both things at the same time, but the objects of change are different: one changes the control structure during inference, and the other changes the input supply before training. So another route began to expand the scope of the closed loop: Can the entire learning and research process become the operating object of the system? The system begins to generate training materials, selects practice strategies, runs experiments, modifies the training process, and then writes the results back to the model or driving equipment. There is a misunderstanding to avoid here. The system's autonomous generation of data or environment only expands the scope of autonomous closed loops. Even if the questions, answers, and corrections 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 gain. SEAL: Let the model generate its own training data and update instructions Give a model new material it has never seen before, and it can usually only learn in ways predetermined by humans. A piece of work in 2025 asked the model to write a "learning plan" for itself first: how to organize the materials, at what pace to learn, and whether it needs to be rewritten multiple times are all decided by the model itself, and then the parameters are updated according to the plan. This is equivalent to arranging your own course schedule and then attending classes according to it. This method is called SEAL (Self-Adapting LLMs) (NeurIPS'25). Whether the plan is good or not depends on "whether the questions are accurate after finishing the class." The system then uses the results to adjust the plan. This is reinforcement learning. In the knowledge question and answer task, this method increased the accuracy from 33.5% to 47.0%, which is also better than directly using GPT-4.1 to generate learning materials. SEAL addresses “how to prepare learning materials for yourself.” But for agents that need to repeatedly interact with the environment, another bottleneck quickly arises: real practice itself is too slow and expensive. So, the next task was to move the environment into a closed loop. SEAL solves "how to prepare learning materials for yourself". But for agents that need to interact repeatedly with the environment, real-life practice is often too slow and expensive: the web environment is too complex, and each operation must be actually executed, and collecting training data is slow and expensive. WebEvolver (EMNLP'25) offers a compromise - training an internal "world model" to simulate how web pages will respond, which is equivalent to building a sandbox in your mind. The agent can practice a lot in the sandbox at low cost, and only go online for verification at critical steps; when performing tasks, the sandbox can also help it predict the results of the next operation. On three real web page task test sets, its overall performance is improved by about 10% compared to existing self-evolving agents, and it does not rely on a stronger "teacher model". At this point, the closed loop can be practiced in the simulation environment. The next question is naturally: Can prediction, evaluation and parameter update leave the web page and be closed in the real physical world? Motus2: When parameter self-improvement enters the physical world Self-improvement doesn't just happen in languages and code. In August 2026, the average success rate of a robotic system on two real-machine tasks increased from 65% to 75%. The change comes from a very specific closed loop: the robot first imagines several actions, predicts the results of each action, selects a better action, 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 results of the actions, and the value model determines whether the results will help complete the task. Predictions and scores are used both to select actions and to update action parameters. This is a weight-level strategy improvement, but it is still a bounded closed loop: the world model backbone and value model remain frozen, task goals and supervision are still provided externally, and the paper does not show that the improved Motus2 is better at designing the next round of learning algorithms. What it proves is that closed loops can be run on real robots, not that open RSI has been done. SEAL, WebEvolver and Motus2 respectively bring training materials, practice environment and physical actions into the closed loop. They expand the scope in which the system can operate autonomously, but still do not leave the decision-making power to the system about "what to study and when to use the results." To see how far this boundary has been advanced in actual research and development, we have to go back to cutting-edge laboratories and production systems. OpenAI and Google: Let agents participate in model development OpenAI's "automated research interns" have been able to troubleshoot, optimize GPU kernel programs, try out training recipes and help improve another model. Google also said that long-running agent loops participate in refining the underlying model. However, neither company has proven a complete autonomous closed loop: humans still decide the research direction and whether the results are advanced, and public information is not enough to restore how the loop operates. The real change is that AI has changed from "the model being studied" to "the executor participating in the research model." 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 the way they do research The first five advancements continued to expand “what can be modified in the system.” A group of work that appeared in the summer of 2026 began to ask head-on: Can the automatic research system be allowed to study and improve the automatic research system itself? On a GPT pre-training benchmark, the ordinary inner loop reduces the verification loss by about 0.009, and adding the outer loop reduces the verification loss by about 0.045 on average, an improvement of about 5 times. Validation loss can be understood as "how wrong" the model is on new data, and usually the lower the better. The comparison here is the loss reduction, not the task accuracy increase of 5 times. Bilevel Autoresearch does this using a two-layer loop: the inner agent optimizes the task code, and the outer agent optimizes the inner search mechanism. What the system has improved is not just the answers, but "how to find the answers." Recursive Harness Self-Improvement (RHI) achieved similar results: on 30 synthetic machine learning research tasks, the updated low-inference-budget agent exceeded the unoptimized highest-budget configuration while reducing inference costs by up to about 60%. Improving the operating mechanism is sometimes more effective than simply increasing the thinking budget. However, both results come primarily from controlled-scale experiments. Proving that a closed loop doesn't just occasionally find a good solution requires longer runs, multiple subsequent versions, and testing outside of the loop. AIDE² tries to put these three things together. What really caused controversy was AIDE². The Weco team asked an automated research agent to act as the outer improver, rewriting the inner AIDE's driving tool in 100 consecutive steps. During 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 exceeded the version that had been manually tuned for two years, and brought the gains to tasks that the loop had never seen before. Another change occurred with reward cheats. In the GPU kernel program test KernelBench that did not participate in optimization, 63% of the test cases in the initial version had a situation where "the public score seemed to be improved, but the hidden verification was not recognized." The best evolved version drops this to 34%. The private score here is a score that cannot be seen during system optimization and is only used during final acceptance. It may have eliminated versions that would only cater to public scores. Weco calls this Level 1: Net Positive Improvement. This isn't a common industry standard, but it's evidence of bounded RSI that deserves to be taken seriously right now. The boundaries of the evidence are also clear: the results come from the team's self-reports, the full report is still to be released, and there are recurrences in the evolved system. Complexity bloat and dead code. More critically, it failed the next-level ignition test: the improved system didn't prove to be any better than its predecessor at improving another version. The reverse evidence comes from AI4AI-Bench. It allows the agent to rewrite the training algorithm within a fixed resource, which is then scored by an evaluator that is inaccessible to the agent. Taking the original algorithm as 0.1 and the task optimal value as 1.0, the strongest system only gets 0.250, and most submissions do not actually modify the model "how to learn". Currently, agents are very good at repairing projects, adjusting driving equipment, and running experiments, but their ability to touch the core of training algorithms is still very shallow. Bottom line: The closed loop has been able to spin a few times net-positively, but it has not been proven that the next lap will spin faster because of the previous one. Unified perspective: How to judge where RSI has gone The following table uses the four criteria at the beginning (persistent improvement, autonomous closed-loop, recursive gain, robustness and controllability) to compare the previous advancements and mark the main gaps. Almost all related work on the meta-research closed loop comes from arXiv preprints in recent months in 2026, among which AIDE² is a self-reported blog result by the team, which has not yet been peer-reviewed. These conclusions should be viewed as staged observations rather than settled consensus. ✅ in the table indicates that there is relatively direct evidence, ⚠️ indicates that it is only established under limited conditions or the evidence is still insufficient, and ❌ indicates that it has not yet been demonstrated. The history of this field is the history of "objects that can be changed by the system" advancing layer by layer. The objects that were changed gradually went from output and memory to parameters, evaluation, driving equipment and training environment, and finally encountered the mechanism itself that produced the improvement. The further in you go, the harder it is to define "improvement" and the harder it is to prove. Returning to the previous four criteria - lasting improvement, autonomous closed-loop, recursive gain, robustness and controllability - what really blocks ignition and open RSI today is the most difficult place to cross in each of the last three criteria, which can be broken down into four interlocking doors. The first gate (whether the autonomous closed loop is reliable): whether the verifier is reliable and the system cannot change it. When the system is both an improver and a judge, the criteria for judging can drift over iterations. Meta-Rewarding's "judges' judges" later became more and more biased toward high scores, and EURISKO learned earlier to stuff his name into the credit book. They all remind you of the same thing: the optimization process attacks every crack between your metrics and your true goals. The external anchor here refers to an evaluation or constraint that cannot be tampered with by the improved system. Formal proofs, executable verifiers, and hidden tests are generally more reliable than model self-evaluation. AIDE²’s hidden score can reduce some reward cheating precisely because the inner agent cannot manipulate it. A truly solid principle is not to have people audit every step, but rather: evaluators and permission boundaries must remain outside the control of the system being evolved. Math and coding tasks can rely on provers, compilers, or hidden tests. Research tastes, long-term code health, and deployment boundaries still require final human judgment. The second door (one that is robust and controllable): whether improvements can extend beyond one’s own data distribution. Training yourself with self-generated data will amplify existing deviations, smooth out diversity, and eventually lead to model collapse: the output becomes more and more monotonous, and original errors are repeatedly amplified in rounds of self-training. If you use a fixed question bank to modify the driving tool, you may write the question bank features into the workflow, creating another kind of over-fitting. One improvement on an unseen mission is not enough. The system must undergo hidden evaluation across tasks, domains, and time to demonstrate that it is accumulating transferable abilities rather than more hidden test-taking skills. The third gate (the recursive gain itself): whether the improvement actually has a recursive gain. Increasing the task score does not mean that the system will design the next improvement. AIDE² demonstrates multi-step net positive improvement without passing ignition. AI4AI-Bench shows that most systems still do not modify the core learning algorithm. When the foundation is too weak, the quality of self-generated data and self-diagnostics can also spiral the cycle further and further. The fourth gate (robust and controllable 2): whether capabilities, complexity and control can be expanded together. The stronger you become, the more "obedient" you are, and the more you can change the code, the easier it is to maintain. AIDE²’s dead code and complexity inflation are a small-scale warning. In larger training systems, the higher the authority and the faster the iteration, the harder it is for humans to understand what each change brings. OpenAI chief scientist Jakub Pachocki publicly stated that no laboratory has solved alignment and monitoring enough to responsibly scale at full speed in the long term. The real goal is not to just move the capability curve up, but to have security, monitoring, rollback, and audit capabilities at least move up simultaneously. AutoResearchEval examined 800 real scientific research trajectories and summarized 45 types of failures. They ultimately point to the same gap: current agents lack a stable metacognitive loop and are unable to continuously check conclusions and evidence, reliably fall back when errors occur, or actively question their own research paths. The problem cannot be solved solely by multiple sets of workflows. Therefore, the more likely realistic picture is not that humans are simply kicked out of the closed loop, but that they move up the abstract ladder: from writing code to testing code, from running experiments to design verification, from local execution to deciding what is worth researching, what evidence is enough to advance, and when it is necessary stop. Machines are taking over more and more jobs, and what humans are left with is not the right to operate every step, but the power to achieve goals, verification boundaries, and final veto. Conclusion: The self-improvement closed loop has emerged, but the recursive gain still needs to be proven. From 1981, when EURISKO learned to “deceive itself”, to 2026, when the model began to participate in evaluation, modification of driving equipment, strategy updates, and subsequent training, a more accurate conclusion is that a bounded, measurable self-improvement closed loop has emerged, and has even begun to generate net positive benefits, but there is no sufficient public evidence that the improved system has continuously improved its own improvement capabilities. Therefore, the way the closed loop closes is more important than the closed loop closing itself. A closed loop that closes in the drift of criteria becomes increasingly adept at optimizing its own distorted goals. A closed loop that closes in the data distribution collapse becomes increasingly good at a narrower and narrower subset of tasks. A closed loop in the amplification of alignment deviations becomes increasingly capable and difficult to correct. The real questions have become two questions: will it ignite, and what will remain outside its unchangeable boundaries when it ignites? The former depends on whether improved capabilities can be recursively gained, and the latter depends on whether verification, authority, and governance can continue to be effective. Go back to EURISKO, who put his name on the list of "discoverers" forty years ago. The loophole it took advantage of is actually the same problem faced by today's most cutting-edge self-evolving systems: when a system starts to score itself, how do you know whether it has really gotten better, or whether it has just learned to make itself look better? Forty years have passed, and the capabilities of the system have become very different, but this problem has remained almost unchanged. What has changed is the stakes: what was won or lost in a board game back then may be the way scientific research and economic systems operate in the future. How this gap finally closes still depends on when and how we put our hands on it, or withdraw it.
स्रोत पढ़ेंChange the wording"] --> B["Context structure
What to change"] B --> C["Workflow
Change Steps"] C --> D["Driving equipment code
Change the entire arrangement"] D --> E["Optimizer code
change "how to change" itself"] The further in, the greater the leverage for change, and the closer it is to "the system rewrites the operating logic by itself." Let’s follow this ladder and look at it from shallow to deep. OPRO: Let the prompt words iterate by themselves Can the system become stronger by leaving the parameters unchanged and only changing the prompt words, which are the words we give instructions to the model? The approach of OPRO (ICLR 2024) is very representative. It gives the tried prompt words and corresponding scores to the model, allowing the model to summarize the rules and generate a better version. In the past, the "tuning skills" relied on people's trial and error, but now the model can be iterated on its own. But the upper limit is clear: no matter how good the prompt word is, it is only calling on the existing capabilities of the model and cannot create new capabilities. ADAS and AFlow: Automated Design Agent Workflows Going one layer further down, what is optimized is no longer just the wording, but the information fed to the model and how the entire task process is arranged. For example, AI Scientist puts together an assembly line of “proposing ideas → writing code → running experiments → writing papers → peer review”. Since a process can be written into code, it can also be searched. ADAS (ICLR 2025) turns the “design workflow” itself into an optimization problem. A higher-level "designer agent" continuously writes new workflows in code, runs them, filters them, and then modifies them, and so on. AFlow (ICLR 2025) goes one step further. It represents the workflow as a flow chart composed of model calls and logical judgments, and then uses search algorithms to find better structures, ultimately surpassing manually designed solutions. Self-Harness and DGM: Let the system rewrite the Harness code The top of the ladder is for the system to directly rewrite the code that defines how it operates. There are two routes here. The first way is to "propose, evaluate and accept". The system finds its own problems, proposes modifications, and then adopts them after verifying that they are effective. Self-Harness (2026) adds strict acceptance conditions: the system first summarizes the reasons for failure, and then makes small, reversible modifications. The new version will be retained only 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 leaves better versions through experiments. The Darwin Gödel Machine (DGM) (2025) directly evolves self-modifying driving code. On the premise that the base model remains unchanged, its repair success rate on SWE-bench Verified increases from 20% to 50%. Behind both paths is the same insight: code is the universal language for defining systems. Once the vehicle is written into executable, scoreable code, programming agents can search the design space. MetaClaw and AgentX: Let real users be the source of feedback No matter which path you take, the self-evolution of driving equipment requires a signal of "whether the modification is good or not." The improvement signal of DGM comes from the fixed test set. MetaClaw (2026) allows the agent to extract experience from dialogue in real deployment, and solidifies the experience into weights in the background, pushing self-evolution from question bank-driven to user-driven. There are already people in the industry who are running this route into real business. Kuaishou's AgentX (2026) will review the execution records, modify the sub-agent's driving equipment accordingly, and then use historical tasks to filter new versions. It uses a similar "propose, evaluate, accept" skeleton as Self-Harness. The difference is that it ultimately undergoes real online A/B testing. The user's stay and consumption behavior become the reward signal of the system. The essential difference between these methods is not in the mechanism, but in who the coach is: a test set, real users, or an online business. The closer the coach is to reality, the more likely it is that the improvements will actually work, but the greater the risk of being taken advantage of. The boundary of the fourth advancement: The operating architecture can be changed, but the verification boundary and final goal are still external. This advancement has also turned the methods of calling models, tools, and memories into evolvable objects. But which direction the driving tool evolves is still determined by external tasks, validators, or user goals. More importantly, a higher score for the driving instrument does not mean that the intelligence of the base becomes stronger. Just because a system will modify the driving equipment does not mean that the updated driving equipment will be effectively used by it. Bottom line: The system is finally able to reinvent its own limbs and workbench, with acceptance criteria and construction boundaries still being defined by the outside world. Fifth push (2025–2026): Put the learning and research process into a closed loop Modifying the driving tool is one route, but what changes the driving tool is how the system performs tasks during runtime - which tool to call, which process to follow, and when to stop. The fifth push is to change the more upstream layer: the materials used by the system to learn and the venue itself - where the practice questions come from, what the practice environment looks like, and how the training data is generated. The former determines how existing capabilities are used, and the latter determines what kind of experience the next version of the model will be trained on. The timelines of the two are highly overlapping, because many teams are doing both things at the same time, but the objects of change are different: one changes the control structure during inference, and the other changes the input supply before training. So another route began to expand the scope of the closed loop: Can the entire learning and research process become the operating object of the system? The system begins to generate training materials, selects practice strategies, runs experiments, modifies the training process, and then writes the results back to the model or driving equipment. There is a misunderstanding to avoid here. The system's autonomous generation of data or environment only expands the scope of autonomous closed loops. Even if the questions, answers, and corrections 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 gain. SEAL: Let the model generate its own training data and update instructions Give a model new material it has never seen before, and it can usually only learn in ways predetermined by humans. A piece of work in 2025 asked the model to write a "learning plan" for itself first: how to organize the materials, at what pace to learn, and whether it needs to be rewritten multiple times are all decided by the model itself, and then the parameters are updated according to the plan. This is equivalent to arranging your own course schedule and then attending classes according to it. This method is called SEAL (Self-Adapting LLMs) (NeurIPS'25). Whether the plan is good or not depends on "whether the questions are accurate after finishing the class." The system then uses the results to adjust the plan. This is reinforcement learning. In the knowledge question and answer task, this method increased the accuracy from 33.5% to 47.0%, which is also better than directly using GPT-4.1 to generate learning materials. SEAL addresses “how to prepare learning materials for yourself.” But for agents that need to repeatedly interact with the environment, another bottleneck quickly arises: real practice itself is too slow and expensive. So, the next task was to move the environment into a closed loop. SEAL solves "how to prepare learning materials for yourself". But for agents that need to interact repeatedly with the environment, real-life practice is often too slow and expensive: the web environment is too complex, and each operation must be actually executed, and collecting training data is slow and expensive. WebEvolver (EMNLP'25) offers a compromise - training an internal "world model" to simulate how web pages will respond, which is equivalent to building a sandbox in your mind. The agent can practice a lot in the sandbox at low cost, and only go online for verification at critical steps; when performing tasks, the sandbox can also help it predict the results of the next operation. On three real web page task test sets, its overall performance is improved by about 10% compared to existing self-evolving agents, and it does not rely on a stronger "teacher model". At this point, the closed loop can be practiced in the simulation environment. The next question is naturally: Can prediction, evaluation and parameter update leave the web page and be closed in the real physical world? Motus2: When parameter self-improvement enters the physical world Self-improvement doesn't just happen in languages and code. In August 2026, the average success rate of a robotic system on two real-machine tasks increased from 65% to 75%. The change comes from a very specific closed loop: the robot first imagines several actions, predicts the results of each action, selects a better action, 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 results of the actions, and the value model determines whether the results will help complete the task. Predictions and scores are used both to select actions and to update action parameters. This is a weight-level strategy improvement, but it is still a bounded closed loop: the world model backbone and value model remain frozen, task goals and supervision are still provided externally, and the paper does not show that the improved Motus2 is better at designing the next round of learning algorithms. What it proves is that closed loops can be run on real robots, not that open RSI has been done. SEAL, WebEvolver and Motus2 respectively bring training materials, practice environment and physical actions into the closed loop. They expand the scope in which the system can operate autonomously, but still do not leave the decision-making power to the system about "what to study and when to use the results." To see how far this boundary has been advanced in actual research and development, we have to go back to cutting-edge laboratories and production systems. OpenAI and Google: Let agents participate in model development OpenAI's "automated research interns" have been able to troubleshoot, optimize GPU kernel programs, try out training recipes and help improve another model. Google also said that long-running agent loops participate in refining the underlying model. However, neither company has proven a complete autonomous closed loop: humans still decide the research direction and whether the results are advanced, and public information is not enough to restore how the loop operates. The real change is that AI has changed from "the model being studied" to "the executor participating in the research model." 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 the way they do research The first five advancements continued to expand “what can be modified in the system.” A group of work that appeared in the summer of 2026 began to ask head-on: Can the automatic research system be allowed to study and improve the automatic research system itself? On a GPT pre-training benchmark, the ordinary inner loop reduces the verification loss by about 0.009, and adding the outer loop reduces the verification loss by about 0.045 on average, an improvement of about 5 times. Validation loss can be understood as "how wrong" the model is on new data, and usually the lower the better. The comparison here is the loss reduction, not the task accuracy increase of 5 times. Bilevel Autoresearch does this using a two-layer loop: the inner agent optimizes the task code, and the outer agent optimizes the inner search mechanism. What the system has improved is not just the answers, but "how to find the answers." Recursive Harness Self-Improvement (RHI) achieved similar results: on 30 synthetic machine learning research tasks, the updated low-inference-budget agent exceeded the unoptimized highest-budget configuration while reducing inference costs by up to about 60%. Improving the operating mechanism is sometimes more effective than simply increasing the thinking budget. However, both results come primarily from controlled-scale experiments. Proving that a closed loop doesn't just occasionally find a good solution requires longer runs, multiple subsequent versions, and testing outside of the loop. AIDE² tries to put these three things together. What really caused controversy was AIDE². The Weco team asked an automated research agent to act as the outer improver, rewriting the inner AIDE's driving tool in 100 consecutive steps. During 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 exceeded the version that had been manually tuned for two years, and brought the gains to tasks that the loop had never seen before. Another change occurred with reward cheats. In the GPU kernel program test KernelBench that did not participate in optimization, 63% of the test cases in the initial version had a situation where "the public score seemed to be improved, but the hidden verification was not recognized." The best evolved version drops this to 34%. The private score here is a score that cannot be seen during system optimization and is only used during final acceptance. It may have eliminated versions that would only cater to public scores. Weco calls this Level 1: Net Positive Improvement. This isn't a common industry standard, but it's evidence of bounded RSI that deserves to be taken seriously right now. The boundaries of the evidence are also clear: the results come from the team's self-reports, the full report is still to be released, and there are recurrences in the evolved system. Complexity bloat and dead code. More critically, it failed the next-level ignition test: the improved system didn't prove to be any better than its predecessor at improving another version. The reverse evidence comes from AI4AI-Bench. It allows the agent to rewrite the training algorithm within a fixed resource, which is then scored by an evaluator that is inaccessible to the agent. Taking the original algorithm as 0.1 and the task optimal value as 1.0, the strongest system only gets 0.250, and most submissions do not actually modify the model "how to learn". Currently, agents are very good at repairing projects, adjusting driving equipment, and running experiments, but their ability to touch the core of training algorithms is still very shallow. Bottom line: The closed loop has been able to spin a few times net-positively, but it has not been proven that the next lap will spin faster because of the previous one. Unified perspective: How to judge where RSI has gone The following table uses the four criteria at the beginning (persistent improvement, autonomous closed-loop, recursive gain, robustness and controllability) to compare the previous advancements and mark the main gaps. Almost all related work on the meta-research closed loop comes from arXiv preprints in recent months in 2026, among which AIDE² is a self-reported blog result by the team, which has not yet been peer-reviewed. These conclusions should be viewed as staged observations rather than settled consensus. ✅ in the table indicates that there is relatively direct evidence, ⚠️ indicates that it is only established under limited conditions or the evidence is still insufficient, and ❌ indicates that it has not yet been demonstrated. The history of this field is the history of "objects that can be changed by the system" advancing layer by layer. The objects that were changed gradually went from output and memory to parameters, evaluation, driving equipment and training environment, and finally encountered the mechanism itself that produced the improvement. The further in you go, the harder it is to define "improvement" and the harder it is to prove. Returning to the previous four criteria - lasting improvement, autonomous closed-loop, recursive gain, robustness and controllability - what really blocks ignition and open RSI today is the most difficult place to cross in each of the last three criteria, which can be broken down into four interlocking doors. The first gate (whether the autonomous closed loop is reliable): whether the verifier is reliable and the system cannot change it. When the system is both an improver and a judge, the criteria for judging can drift over iterations. Meta-Rewarding's "judges' judges" later became more and more biased toward high scores, and EURISKO learned earlier to stuff his name into the credit book. They all remind you of the same thing: the optimization process attacks every crack between your metrics and your true goals. The external anchor here refers to an evaluation or constraint that cannot be tampered with by the improved system. Formal proofs, executable verifiers, and hidden tests are generally more reliable than model self-evaluation. AIDE²’s hidden score can reduce some reward cheating precisely because the inner agent cannot manipulate it. A truly solid principle is not to have people audit every step, but rather: evaluators and permission boundaries must remain outside the control of the system being evolved. Math and coding tasks can rely on provers, compilers, or hidden tests. Research tastes, long-term code health, and deployment boundaries still require final human judgment. The second door (one that is robust and controllable): whether improvements can extend beyond one’s own data distribution. Training yourself with self-generated data will amplify existing deviations, smooth out diversity, and eventually lead to model collapse: the output becomes more and more monotonous, and original errors are repeatedly amplified in rounds of self-training. If you use a fixed question bank to modify the driving tool, you may write the question bank features into the workflow, creating another kind of over-fitting. One improvement on an unseen mission is not enough. The system must undergo hidden evaluation across tasks, domains, and time to demonstrate that it is accumulating transferable abilities rather than more hidden test-taking skills. The third gate (the recursive gain itself): whether the improvement actually has a recursive gain. Increasing the task score does not mean that the system will design the next improvement. AIDE² demonstrates multi-step net positive improvement without passing ignition. AI4AI-Bench shows that most systems still do not modify the core learning algorithm. When the foundation is too weak, the quality of self-generated data and self-diagnostics can also spiral the cycle further and further. The fourth gate (robust and controllable 2): whether capabilities, complexity and control can be expanded together. The stronger you become, the more "obedient" you are, and the more you can change the code, the easier it is to maintain. AIDE²’s dead code and complexity inflation are a small-scale warning. In larger training systems, the higher the authority and the faster the iteration, the harder it is for humans to understand what each change brings. OpenAI chief scientist Jakub Pachocki publicly stated that no laboratory has solved alignment and monitoring enough to responsibly scale at full speed in the long term. The real goal is not to just move the capability curve up, but to have security, monitoring, rollback, and audit capabilities at least move up simultaneously. AutoResearchEval examined 800 real scientific research trajectories and summarized 45 types of failures. They ultimately point to the same gap: current agents lack a stable metacognitive loop and are unable to continuously check conclusions and evidence, reliably fall back when errors occur, or actively question their own research paths. The problem cannot be solved solely by multiple sets of workflows. Therefore, the more likely realistic picture is not that humans are simply kicked out of the closed loop, but that they move up the abstract ladder: from writing code to testing code, from running experiments to design verification, from local execution to deciding what is worth researching, what evidence is enough to advance, and when it is necessary stop. Machines are taking over more and more jobs, and what humans are left with is not the right to operate every step, but the power to achieve goals, verification boundaries, and final veto. Conclusion: The self-improvement closed loop has emerged, but the recursive gain still needs to be proven. From 1981, when EURISKO learned to “deceive itself”, to 2026, when the model began to participate in evaluation, modification of driving equipment, strategy updates, and subsequent training, a more accurate conclusion is that a bounded, measurable self-improvement closed loop has emerged, and has even begun to generate net positive benefits, but there is no sufficient public evidence that the improved system has continuously improved its own improvement capabilities. Therefore, the way the closed loop closes is more important than the closed loop closing itself. A closed loop that closes in the drift of criteria becomes increasingly adept at optimizing its own distorted goals. A closed loop that closes in the data distribution collapse becomes increasingly good at a narrower and narrower subset of tasks. A closed loop in the amplification of alignment deviations becomes increasingly capable and difficult to correct. The real questions have become two questions: will it ignite, and what will remain outside its unchangeable boundaries when it ignites? The former depends on whether improved capabilities can be recursively gained, and the latter depends on whether verification, authority, and governance can continue to be effective. Go back to EURISKO, who put his name on the list of "discoverers" forty years ago. The loophole it took advantage of is actually the same problem faced by today's most cutting-edge self-evolving systems: when a system starts to score itself, how do you know whether it has really gotten better, or whether it has just learned to make itself look better? Forty years have passed, and the capabilities of the system have become very different, but this problem has remained almost unchanged. What has changed is the stakes: what was won or lost in a board game back then may be the way scientific research and economic systems operate in the future. How this gap finally closes still depends on when and how we put our hands on it, or withdraw it.