Recently, IQuest Research, in partnership with Beijing Aerospace University and the University of Manchester, released Modular RSI in an attempt to enable Agent to continuously modify the operating mechanisms surrounding the model based on its own execution experience.
In the case of a complete freeze of the base model, after the evolution of Harness, the system's accuracy rate on Terminal-Bench 2.0 has been reduced from47.57 increased to 52.43More importantly, these improvements can also migrate to non-evolutionary tasks, different fields and even different base models.
arXiv：
Code:
Blog:
The core question of this work is straightforward: how can Agents work on the mold to achieve continuous self-improvement by modifying the mold when the model itself is no longer changing?
The research team wrote an Agent:
A=(M,H)
Among them, M is the basic model and H is the Harness.
For today's Agent, the end performance is increasingly dependent on systemic mechanisms outside the model. The model's ability to see what environmental information, how to maintain context, when to call tools, how to recover after failure, and under what circumstances to declare a task completed, all affect the end result.
These mechanisms together make up Harness.
ModularRSI further places the objects of change on Harness:
The model (M) is always frozen and Harness changes with the execution experience.
Every time an agent completes a set of tasks, it leaves an execution trajectory; the system searches the trajectory for repeated defects, then modifies its own running code, so that the next round of execution builds on the previous round of experience.
This is called Harness Recursive Self-Improvement.Harness RSI。
Performance of the harness across different evolution generations on Terminal-Bench 2.0
Video 1 demonstrates this phenomenon: the basic model stays frozen, the peripheral harness continues to improve with the evolution of iteration, and the performance of Terminal-Bench 2.0. According to the authors, the improvement in the iterative capabilities of the Agent may not necessarily be accompanied by a model overhaul, improvement in the way intelligence is organized and summoned, and may also lead to performance improvements.
However, just looking at an ever-increasing benchmark curve, it's hard to prove that real self-improvement has occurred.
Figure 2｜A case showing that the overfitting issue of modern agents is much more in disguise than traditional machine learning
If an Agent repeatedly executes on the same class of tasks and continually modifies code to address failures, it is easy to become familiar with the task structure, tool settings and common failures patterns of a specific benchmark. The scores will continue to rise, but what Harness learns may be only local strategies.Self-improvement is only truly meaningful when improvement can be generalized to the experience that produces these improvements.
Around this standard, ModularRSI separated Harness evolution from final evaluation strictly. The team constructed a data pool containing 2000 high-quality instances, from which they extracted two non-overlapping evolutionary sets: 120 Terminal-Bench related instances and 120 SWE-Bench related instances, and evolved TB-evolved and SWE-evolved Harness respectively. At the end of the evolution, Harness was frozen and uploaded to Terminal-Bench 2.0 and SWE-Bench Verified for evaluation.
The focus of research is thus shifted from the fact that hydrogen cannot do its current tasks higher, to whether hydrogen agents have learned repeatable execution mechanisms.
Let's break the Harness and let it learn.
Having an LLM read the entire Agent code library directly, and then simultaneously diagnose, modify all the logic, and the search space will rapidly expand. A single failure may also come from multiple locations: tool calling errors, environmental feedback processing incorrectly, context loss, looping logic abnormalities, or early withdrawal when the task is not completed.
Agent Loop: responsible for the mutation process of mutations in mutations observed by mutations in mutations;
Observation Management• Processing and screening of environmental feedback;
Tool Use: Responsible for tool selection, call and parameter construction;
Context ManagementPreserving historical information, task constraints and intermediate results.
Task Completion DetectionIt's time to decide whether the task is actually done.
Overview of Modular RSI: five Harness modules, trajectory analysis, Harness Evolution and the Validation Gate
Each module evolves independently from the same initial Harness. Once a task is completed, the Modular RSI does not modify the code immediately based on a single failed trajectory. For the same task, it performs multiple rollouts and forms several different comparisons based on the execution results:
If all tracks are successful, the system continues to check for repetitive operations, surplus-tool calls, or inefficient interactions.
2) The value is higher if the same task has a success and failure trajectory at the same time. The task and environment are consistent, but the results are different, and the system can directly compare the two trajectories to determine exactly which decisions changed the execution results.
3. If all tracks fail, the system further searches for any successful versions of the historical iteration; if still unable to find them, it analyzes problems such as death cycles, incorrect tool calls, weak error recovery or early termination.
These tracks are then organized into structured findings: which Harness function may have problems, where the evidence comes from, and how to modify it. Only when similar defects occur repeatedly in multiple tasks and tracks does it receive a higher modification priority.
In addition, the code must be repeatedly verified in three ways before being rewritten by Harness:Program CheckThe second way is to check the accuracy of basic procedures, such as grammar, import, interface contracts, and so on.Diff ReviewThe focus is on finding task-specific constants, individual instance-oriented solutions, and inspirational rules that may only be applicable to the current batch.Execution ValidationThe Harness can be modified to restore the actual execution of the task. New running errors also cannot be saved.
Finally, ModularRSI would obtain independent evolution of five modules, respectively, and further execute an epoch of co-evolution on the evolutionary cluster through the Cross-Module Integration mechanism, integrating the improvements of each module, resulting in the final evolved harness. At the same time, the research team also introduced two mechanisms: Function Merge and Task-Aware Function Composition: the former is used to combine functions that are close to or have redundant functions to reduce function duplication and potential conflicts; and the latter, based on the needs of different tasks, selects dynamics from each module and combines the appropriate functions to enable the final harness to use more appropriate execution capabilities for specific tasks.
This mechanism brings Harness' evolution closer to a constrained software generation process: execution generates experience, experience forms diagnosis, diagnosis enters code; and code is only validated to become part of the next generation of systems.
The model hasn't changed, the capabilities can move.
In the end, the experiment proved that Harness himself had a considerable amount of optimization space.
In Terminal-Bench 2.0, the accuracy of the original Harness is as follows:47.57The modular RSI has been upgraded to a modular RSI.52.43It's up to you.4.86 points。
Separately observing the different modules, you can also see the apparent functional breakdowns. Among them, the single module accuracy rate brought by Agent Loop increased the most, to about.2.99 pointsObservation Management's improvements in execution efficiency are more pronounced, with an average decrease in interaction steps.35%。
It is worth noting that when all the modules are directly combined together, the result is a decrease.44.19The first step is to allow the individual modules to evolve independently, and then to combine the effective capabilities to reach 52.43.
This indicates that there is a strong correlation within the Harness. After a locally effective change enters the system as a whole, other modules may change working conditions and even create new conflicts.
In addition to verifying the evolution of Harness on TerminalBench and SWE-Bench Verified in an in-domain setting, the research team then moved the range of testing from a single benchmark to cross-domain. The Harness evolved on Terminal-Bench-related tasks, placed on SWE-Bench Verified, improved the accuracy by 2.40 percentage points compared to the original Harness. Conversely, the Harness evolved on SWE-related tasks, for Terminal-Bench 2.0, also received a 1.83 percentage point improvement.
Harness was originally developed on the basis of DeepSeek-V4-Flash Preview, which was later frozen and combined with GLM-5.2 and MiniMax-2.5 respectively.59,55 to 61,80.The MiniMax-2.5 is from41.57 increased to 44.94DeepSeek-V4-Flash is based on the concept of "deepseek".47.57 increased to 52.43。
This means that part of the Harness layer experience is not completely tied to a particular base model. Reducing meaningless cycles, improving error recovery, improving the reliability of task completion is not entirely determined by the model itself. For Harness RSI, this migration capability is more important than performance improvements on a single benchmark, because it directly corresponds to the judgement criteria that the study originally proposed: optimization cannot be detached from the experience that generates it to continue to exist.
The agent's ability to improve as quickly as possible.
It's just a matter of completing a task that's not going to get done.
In the experiment, the team also discovered another interesting phenomenon: the difficulty of data used to evolve directly affects how much Harness can learn from it.
The researchers constructed two data distributions: one group focused on medium-difficulty tasks, with about half the success rates of 40 to 60%; the other group consisted mainly of ultra-simple and ultra-difficult tasks.58.4% increased to 65.0%This is an increase of 6.6 percentage points, while the Hard & Easy setup only improved.0.6 percentage points。
Figure 3 Middle-difficulty evolution compounds; Hard & Easy stalls: Harness evolutionary curves under different difficulty distributions
The reason is directly related to how Modular RSI learns. The task is too simple, most tracks are successful, and the system has difficulty obtaining valuable evidence of failure. The task is too difficult, most tracks fail, and the system lacks a successful version as a reference.
This also means that if Harness RSI were to evolve further in the future, data building would become just as important as model training. In addition to the scale of the task, the difficulty distribution, the variety of trajectories and the success rate of failures may directly determine what the Agent can ultimately extract from its own experience.
From running erroneous commands eight times in a row, to a general recovery mechanism
Harness also has a natural advantage over model weight: researchers can see directly what it has learned. The study gives a complete evolutionary case of Agent Loop.
In one failed mission, the Agent executed the same invalid command eight times in a row, then repeatedly claimed the task was completed. Verifier refused, and the Agent eventually ran out of execution budget.guarded_completionIt is used to prevent unproven tasks from completing statements while identifying repeating commands. The subsequent trajectory also exposes formatting errors, which further adds to the system.parse_error_recoveryTo help Agent identify and correct previous malformed output.
In retrospect, a new failure emerged: The agent stopped completely repeating the same command, but it could take a long time to execute.ls、cat、grepThe system continued to expand the mechanism, and began to detect this long-term exploration without editing, building or testing the worm. Afterwards, Harness also evolved.planning_checklistFollow up on what needs have been completed, what are still being addressed, and further combine logic with previous mistakes.
A case study of the function merge: from guarded_completion、completion_integrity_guard、planning_checklist to planning_with_guard
What is remarkable about this process is that a specific string failure string is abstracted into more general mechanisms such as repeat detection, judgment, error recovery, stagnation identification, and planning management. This is also the most important difference between the Harness RSI and simple experience memory.
However, after each module learns the effective mechanism, new problems arise: these capabilities come together and sometimes fight each other.
The team found that the evolved Agent Loop and Verification had benefits when running separately. However, after the combination, both sides contained their own completion judgments, equivalent to two completion gates simultaneously appearing within the system. The agent may have passed through one layer but was blocked by another layer, then continued to complete the loop between the loops until the task was over.
This further demonstrates that Harness evolution needs to optimize the relationships between the modules.
Self-improvement starts from the model to the whole system.
Finally, the team attempted to answer a more basic question: did these code changes correspond to the improvement in Agent behavior itself?
They used an LLM judge to evaluate the trajectory of different Harness evolutionary iterations from task effectiveness, interaction quality, process reliability, context to state management, efficiency and robustness. The results showed that as Terminal-Bench accuracy rates improved, behavior scores also showed a fundamentally consistent growth trend.
Figure 5｜Consistency between Harness Performance Improvement and LLM-based Behavioral Evaluation during RSI
This type of behavior rating cannot replace cross-task, cross-domain and cross-model experiments, but it provides another layer of evidence: performance changes are accompanied by observable changes in execution behavior.
From this point of view, Modular RSI provides Agent with a more specific engineering implementation of self-improvement. Classic recursive self-improvement typically associates system capacity growth with the update of the model itself; Harness RSI shows another possible axis of evolution.
Models continue to determine the boundaries of capabilities, while Harness determines how these capabilities enter the actual execution process. Stronger models can lead to better knowledge, reasoning, and internal representation; better Harness can improve tool calling, context management, error recovery, execution efficiency, and task completion judgement. As the Agent begins to take on longer, more complex real tasks, these two layers of optimization will inevitably complement each other.
Modular RSI is still in its early stages. Further exploration of how different modules evolve more stably together, which data is best suited to Harness RSI, whether larger data and more rounds of evolution can continue to generate steady gains, and how different types of models will affect the evolutionary direction of Harness, remains to be seen.
But at least this study has shown a clear phenomenon:After the model weight freezes, the agent can still find its own systemic flaws in the execution experience, rewrite those experiences into Harness, and build the next round of execution on the previous round.
As the object of study expanded from the model to the entire operating system in which the model is located, the Agent's self-improvement algorithm also began to have new pathways to realization.