Rewriting Its Own Code Is Not True Self-Evolution: A Chinese Research Team Divides RSI into Five Levels

The crypto industry is moving toward a world where software agents can monitor markets, write smart contracts, rebalance portfolios, manage liquidity, and interact with decentralized applications. As these systems become more autonomous, one question is becoming increasingly important:

When can an AI agent truly be described as self-evolving?

A recent survey by researchers from Shanghai Jiao Tong University, Tsinghua University, ByteDance, Xiaohongshu, Shanghai AI Laboratory, and other institutions proposes a stricter answer. The paper, The Last AI Built by Humans, reviews 491 studies and introduces a five-level framework for evaluating recursive self-improvement, or RSI.

Its central argument is simple but consequential:

An AI that can rewrite its own code may still be far from truly improving itself.

That distinction matters greatly for blockchain and crypto. In this sector, an autonomous agent may be able to deploy contracts, change trading strategies, or update its own software. But if humans still determine the evaluation criteria, approve every meaningful change, and control the mechanism that selects the next version, the system may be autonomous in execution without being recursively self-improving.

Why Recursive Self-Improvement Matters in Crypto

Blockchain applications are unusually well suited to autonomous software. Smart contracts provide programmable execution, public ledgers provide transparent records, and decentralized protocols create environments where agents can interact continuously with markets and other applications.

This has already encouraged the development of:

• AI-powered trading and portfolio agents
• Automated market-making systems
• On-chain treasury managers
• Smart contract auditing tools
• Governance assistants
• Autonomous payment and settlement systems
• Agent-to-agent commerce using crypto assets

The arrival of account abstraction and programmable wallet infrastructure is making these use cases more flexible. Ethereum’s account abstraction roadmap describes how accounts can support more complex authorization rules, transaction batching, and automated execution. These capabilities can reduce friction for users, but they also raise a difficult question: who is ultimately responsible for the agent’s decisions?

If an agent can modify its own code, change its risk model, or generate new transaction policies, users need more than a general claim that the system is “autonomous.” They need to understand how the system improves, who defines success, and whether each update is subject to independent verification.

This is where the five-level RSI framework becomes useful.

The Five Levels of Recursive Self-Improvement

The framework distinguishes between increasingly powerful forms of machine-led improvement. The levels are not an industry-wide standard, but they offer a practical vocabulary for analyzing AI systems used in crypto.

Level 1: Following a Human-Designed Improvement Process

At Level 1, an AI system performs an improvement routine designed by humans.

For example, a crypto research agent might:

1. Collect market data.
2. Run a predefined backtest.
3. Select the strategy with the highest historical return.
4. Generate a new configuration.
5. Repeat the process.

The agent may execute the process automatically, but it does not decide how the process itself should work. The search space, evaluation method, and update rules remain fixed.

Many automated trading systems and smart contract optimization pipelines fit this description. They can be useful and highly efficient, but their autonomy is operational rather than recursive.

Level 2: Choosing How to Improve

At Level 2, the system can select or construct its own improvement method within a defined environment.

A blockchain security agent might choose whether to improve by:

• Generating more test cases
• Trying a different fuzzing strategy
• Allocating additional compute to symbolic execution
• Comparing several code-repair approaches
• Selecting a different model or toolchain

The agent now has some discretion over the path it takes. However, the overall objective and the boundaries of acceptable change are still imposed externally.

In crypto, this could enable more efficient smart contract auditing or yield strategy research. Yet the agent is still optimizing inside a framework that humans created.

Level 3: Deciding What to Learn Next

Level 3 gives the system control over the next learning target.

Instead of merely choosing how to optimize a predefined task, the AI can decide which knowledge, capability, or weakness should be addressed next. For an on-chain agent, that might mean identifying that it needs to improve:

• Slippage estimation
• Cross-chain execution reliability
• Governance proposal analysis
• Contract vulnerability detection
• Key-management workflows
• Adversarial transaction recognition

This is an important step because the agent is no longer only searching for a better answer. It is helping define the next problem it should solve.

However, the evaluation mechanism may still be fixed. Humans could continue to decide which benchmarks matter, how performance is measured, and which modifications are allowed to survive.

Level 4: Improving Through Real-World Feedback

At Level 4, the system can continuously modify components such as its memory, skills, code, or execution harness based on feedback from actual operation.

This is especially relevant to crypto because blockchain environments are dynamic and adversarial. Market conditions change, new attack patterns emerge, protocols upgrade, and economic incentives shift. An agent that performs well in a static test may behave very differently when exposed to live liquidity, governance conflicts, or malicious contracts.

A Level 4 agent might:

• Update its memory after observing failed transactions
• Revise its smart contract analysis skills after a new exploit
• Modify its execution code to reduce operational errors
• Improve its transaction simulation process
• Adjust its risk controls after real-world losses
• Carry successful improvements into later tasks

The defining feature is not merely that the agent can edit itself. The changes must influence future performance in an ongoing loop.

For crypto users, this creates a new category of risk. An agent that learns from live events may become more capable, but it may also develop behavior that was not explicitly reviewed in advance. In a financial environment, adaptability must therefore be paired with auditability, permission controls, and clear rollback mechanisms.

Level 5: Modifying the Improvement Process Itself

Level 5 is the most ambitious category. At this stage, the system can alter the mechanisms responsible for producing future improvements.

That may include changing:

• The search algorithm
• The evaluator or scoring function
• The research strategy
• The rules for selecting candidate changes
• The process that decides which modifications are retained
• The infrastructure used to generate the next version

This distinction is critical. A coding agent that rewrites its own source code may look highly autonomous. But if humans still hard-code how candidates are generated, how they are scored, and which version is accepted, the system has not necessarily achieved full recursive self-improvement.

It has demonstrated self-modification, not control over the complete improvement loop.

In a crypto setting, imagine an autonomous treasury agent that can rewrite its portfolio-management code. If the risk model, evaluation benchmark, update approval process, and version-selection rules remain permanently fixed by developers, the system may be powerful but it is not fully recursive in the Level 5 sense.

Formal Recursion Is Not the Same as Getting Stronger

The survey further separates Level 5 into two different achievements.

Formal Recursive Improvement

The first is structural. An AI system can modify the mechanisms that will be used to improve its future versions, and those modifications are carried forward into the next iteration.

This demonstrates that the system has entered a recursive loop. However, recursion alone does not guarantee useful progress.

Verified Capability Growth

The stronger requirement is empirical. The modified improvement process must actually produce a more capable next generation under comparable resources and independent evaluation.

This distinction is essential for crypto infrastructure. A system could repeatedly update its trading code while becoming less robust, more expensive to operate, or more vulnerable to manipulation. It could optimize for a narrow benchmark while losing the ability to handle unexpected market conditions.

For an autonomous smart contract agent, “better” should not mean only higher backtest returns. It may also need to mean:

• Fewer exploitable vulnerabilities
• More reliable transaction execution
• Better resistance to oracle manipulation
• Lower unintended exposure
• More accurate simulation of protocol behavior
• Stronger privacy and authorization guarantees
• Stable performance under adversarial conditions

Independent testing is therefore indispensable. A system should not be allowed to define its own success criteria without external checks.

What the 491-Study Review Suggests

The survey places 43.8% of the reviewed studies at Level 1 and 31.6% at Level 2. Only 29 studies, or 5.9%, are classified at Level 5.

These figures suggest that most current research focuses on executing human-designed improvement procedures or searching for better ways to optimize within predefined boundaries. Far fewer systems are capable of changing the improvement machinery itself.

Even among systems approaching Level 5, the evidence does not yet establish that they can accumulate advantages over long periods in a stable and reliable way.

This is an important correction to the way AI progress is often discussed. Terms such as “self-improving agent,” “autonomous coder,” and “recursive AI” can describe systems with very different capabilities. Without a clear framework, a model that edits a configuration file may be placed in the same category as a system that redesigns and validates its own research process.

The authors also include academic papers, technical reports, official blog posts, and open-source systems. That broader scope is understandable because some of the most advanced AI-agent experiments may appear first as engineering releases rather than traditional research papers.

At the same time, the classification should be treated as a proposed framework, not as a universally accepted industry standard.

What This Means for AI Agents Handling Crypto Assets

The RSI framework has practical implications for anyone building or using crypto-native AI agents.

1. Self-modification should not equal unlimited authority

An agent may be permitted to update its software without being permitted to move funds. These should be separate capabilities.

A secure design can distinguish between:

• Code modification
• Strategy modification
• Transaction proposal
• Transaction approval
• Asset transfer
• Contract deployment
• Governance participation

Separating these permissions reduces the chance that an improvement loop can directly turn into an unrestricted financial action.

2. Every update needs an evaluation boundary

An autonomous agent should not be able to decide that it is successful simply because it generated a higher return in a narrow simulation.

Evaluation should include independent tests for security, reliability, transaction correctness, and abnormal behavior. This principle aligns with the broader risk-management approach described in the NIST AI Risk Management Framework.

For on-chain systems, evaluation may also require forked-network testing, transaction simulation, formal verification, and monitoring after deployment.

3. The improvement loop must be observable

Users should be able to determine:

• What changed
• Why it changed
• Which data triggered the change
• How the new version was tested
• Who or what approved deployment
• How the change can be reversed

This is particularly important when an agent interacts with irreversible blockchain transactions. Transparency cannot eliminate risk, but it can make failures easier to detect and contain.

4. Key security remains separate from model intelligence

Even the most advanced agent should not automatically control a user’s private keys without carefully designed authorization rules. AI capability does not replace secure key custody.

Hardware wallets can play a role here by keeping signing secrets isolated from general-purpose environments. A product such as OneKey can serve as a user-controlled signing boundary: an AI agent may prepare or recommend an action, while the user or a separate authorization policy decides whether a transaction should actually be signed.

This separation is especially valuable when software can modify itself. The more adaptive the agent becomes, the more important it is to ensure that autonomous code changes do not silently become autonomous control over assets.

A More Careful Definition of “Autonomous”

The crypto industry has strong incentives to market systems as autonomous. Autonomous trading, autonomous governance, and autonomous agents are compelling narratives because they suggest lower operating costs and less human intervention.

But autonomy has multiple dimensions:

• Autonomy in executing tasks
• Autonomy in selecting strategies
• Autonomy in choosing learning goals
• Autonomy in modifying software
• Autonomy in evaluating improvements
• Autonomy in controlling financial authority

These dimensions should not be treated as interchangeable.

A system can be highly autonomous in execution while remaining entirely dependent on human-designed evaluation rules. Another system may be able to rewrite its code but still lack the ability to produce reliable capability gains. The five-level RSI framework helps separate these cases.

For builders, this means technical documentation should describe the exact scope of autonomy rather than relying on broad labels. For users, it means asking a more useful question than “Can this AI improve itself?”

The better question is:

Which part of the improvement process can the AI control, and what prevents that control from becoming an unreviewed financial risk?

The Road Ahead for Crypto-Native AI

The next generation of blockchain agents will likely combine machine learning, smart accounts, programmable authorization, and on-chain data. Ethereum’s work on account abstraction and the growing use of automated transaction policies show how the infrastructure for agent-mediated activity is developing.

But greater programmability also increases the importance of boundaries. A system that can change its code, update its memory, and interact with markets needs more than raw intelligence. It needs a reliable governance layer around permissions, testing, monitoring, and recovery.

The RSI framework does not prove that truly self-improving AI has arrived. Instead, it offers a way to ask more precise questions about claims of machine evolution.

In crypto, that precision can make the difference between an efficient assistant and an uncontrollable financial actor. The most trustworthy architecture may not be the one that gives an AI unlimited independence. It may be the one that allows agents to improve within clearly defined boundaries while keeping critical signing authority, verification, and recovery under human control.