RSIAgent lets open-source models explore new environments—and surpass GPT-6 Astra on OSWorld 2.0 and Agents’ Last Exam

01From passive learning to active exploration: RSIAgent’s core idea

At its core, RSIAgent turns interaction with a new environment into an ongoing learning process. Around an evolving memory, the system builds a multi-agent recursive loop comprising a curriculum agent, an actor agent, and a verifier agent. The curriculum agent decides what to explore next; the actor agent enters the environment to execute tasks and acquire experience; the verifier agent uses feedback from the real environment to determine whether the results are reliable. Useful knowledge is then continuously written into memory. Rather than passively completing tasks, the agent can autonomously choose learning directions, acquire experience, and expand its knowledge of the environment.

Building on this loop, RSIAgent uses a broad-to-deep, two-stage self-exploration strategy. Its rationale resembles pre-training followed by post-training in large models: first establish broad capability coverage through diverse exploration, then reinforce the ability to handle critical difficulties.

Stage 1Broad Recursive Self-exploration

This stage is analogous to pre-training. The emphasis shifts from solving an individual task to quickly building a broad understanding of the environment. In each round, the curriculum agent generates several exploration tasks in different directions—for example, trying different tools, interaction methods, or input conditions. Multiple actor–verifier agent pairs execute and verify them in parallel, consolidating useful experience into shared memory. Based on what has already been learned, the curriculum agent proposes another batch of valuable tasks that cover new directions. The result is a parallel recursive chain:

Tasks in multiple directions→Parallel execution→Parallel verification→Consolidate and update memory→New tasks in multiple directions

By continually expanding the directions of exploration, Broad Recursive Self-exploration quickly covers common rules, operating procedures, and failure modes. It first builds a relatively comprehensive “map of environment knowledge,” laying the foundation for deeper exploration of critical difficulties.

Stage 2Deep Recursive Self-exploration

This stage is closer to post-training. Its focus shifts from covering more knowledge to overcoming critical difficulties, actively seeking problems that are hard, hidden, error-prone, or exposed only under complex conditions. The curriculum agent first generates a relatively difficult task, deliberately taking the system into situations where exceptional states, hidden constraints, or boundary cases may arise. The actor agent uses the current memory to perform the task, and the verifier agent checks the outcome. The curriculum agent then designs a harder task based on the failures, unknowns, and weaknesses just uncovered. The process becomes a sequential recursive chain:

Difficult task→Execution→Verification→Update memory→A harder task

Each round builds on the knowledge acquired in the previous one. Deep Recursive Self-exploration therefore resembles automated “stress testing”: it continually pushes the agent toward the boundaries of its knowledge, helping it understand where the environment is most likely to cause problems.

Finally, the memory accumulated through both stages is frozen and reused directly for subsequent task execution. The agent gains reusable capabilities for a new environment without updating its model parameters.

From exploration to execution: RSIAgent in real software

02Experimental analysis

1.Taking open-source models beyond frontier closed-source models

On OSWorld 2.0 and Agents’ Last Exam, RSIAgent builds on the open-source models GLM-5.3 and Kimi-K3. Its RSI strategy raises the OSWorld 2.0 score from 71.97% to 78.98%, well above frontier closed-source models such as GPT-6 Astra and Claude Opus 5. This shows that, even without parameter updates, agents can continue to extend the capabilities of their underlying models through autonomous exploration and memory evolution.

2.Extending RSIAgent to game environments

We also apply RSIAgent to autonomous game development on GameCraft-Bench. The results show further improvements in mechanics, depth, visuals, art, and overall quality, indicating that its active-exploration and self-evolution mechanism can transfer to different types of interactive environments.

3.Ablating BRS and DRS

The ablation study demonstrates the importance of both Broad Recursive Self-exploration and Deep Recursive Self-exploration. The broad stage quickly establishes coverage of environment knowledge; the deep stage focuses further on difficulties, hidden constraints, and boundary conditions. Removing either stage substantially affects the breadth or depth of exploration.

4.More RSI rounds, continued self-evolution

As the number of RSI rounds increases, agent performance continues to improve. Tasks converge at different rates depending on their difficulty: simpler tasks may reach high scores quickly, while complex tasks require more rounds of exploration to resolve the remaining bottlenecks. On representative tasks, final scores can reach 100%, reflecting a process of recursive evolution reminiscent of human exploration and learning.

03Toward active causal discovery and learning: Scaling Experience for Agents

Over the past few years, advances in AI have largely depended on scaling models. Yet this paradigm remains fundamentally “train first, deploy later.” When a model encounters new software, tools, or environments, it often requires another round of data collection and additional training. It lacks the ability to autonomously develop new knowledge during deployment.

To address this problem, the Aether AI team has been advancing autonomous causal discovery, memory evolution, and self-learning in agents. Causal-Copilot explores how agents can autonomously carry out causal analysis, going beyond correlation to identify the factors that truly influence outcomes. C-World creates open-ended tool-use environments in which agents can continuously test, acquire experience, and construct data through more complex and open-ended interactions. Building on this foundation, Auto-scaling Continuous Memory and Hybrid Self-evolving Structured Memory investigate how this continually generated experience can become scalable, evolving long-term memory. StructAgent further brings these capabilities together in long-horizon digital agents, organizing state, execution, and verification through a unified causal structure.

RSIAgent seeks to move agents from passive training toward active causal discovery and learning—and, ultimately, genuine self-evolution. In a new environment, the agent does not merely record trajectories. It actively decides what to explore next, applies different interventions through ongoing interaction, probing, and verification, and observes their consequences. In doing so, it can gradually discover causal relationships between actions, conditions, and outcomes: which operations cause which changes, which conditions lead to failure, and which key factors can be changed to alter the final result.

This creates another path to scaling: Scaling Experience. With model parameters held fixed, RSIAgent expands the scope of exploration through successive RSI rounds, discovers new causal regularities and environment mechanisms from successes, failures, and boundary cases, and consolidates them into evolvable memory. Memory becomes more than a store of past experience: it gradually develops into a reusable understanding of the environment’s causal structure, supporting subsequent decisions and continued self-evolution.

Tasks of different difficulty also exhibit different “rates of evolution.” Simple tasks may converge after a few RSI rounds, while complex tasks require more active exploration to uncover hidden variables, unknown constraints, and corner cases. In the experiments, some tasks that initially score only 0–40% eventually reach 100% as RSI rounds increase.

The future ceiling of an agent’s capabilities may therefore depend not only on how strong its underlying model is, but also on whether it can continually discover, verify, and accumulate causal knowledge through active intervention—and turn that knowledge into enduring, reusable capabilities. Aether AI will continue pursuing this direction: enabling agents not merely to remember what happened, but to gradually understand why it happened and how changing the causes can change the outcomes, ultimately achieving reliable autonomous evolution.