Self-Evolution

The Evolutionary Dilemma of AI Agents

Current AI Agents, particularly large language model applications, often face two core pain points: "amnesia" across sessions due to isolation and passive execution lacking continuous improvement. Each new session (/new) may start from scratch, losing lessons learned and context from previous interactions. Meanwhile, when executing complex tasks, Agents typically respond passively to commands, lacking the ability to proactively audit their own outputs, correct deviations, and systematically accumulate experience.

How Self-Evolution Works

This skill aims to inject a structured "self-evolution" mechanism into AI Agents. Its core is not about modifying model weights, but achieving continuous behavioral optimization through conversation-driven rule and memory management.

Core Capabilities and Workflow

1. Automatic Session Review and Context Injection
   Once installed, the skill writes a core rule into the Agent's SOUL.md configuration file. This rule ensures that upon detecting the /new command or similar signals to start a new session, the Agent will automatically scan and read learning records left from the last session (typically stored in the .learnings/ directory), injecting key lessons and context into the current session, thus overcoming the fundamental session amnesia of base models.

2. Real-time Metacognition and Introspection Framework
   The skill defines a prioritized set of self-check rules (P0-P6) for the Agent, internalized as triggers:

   • P0 (Highest Priority): When the Agent hesitates before generating content, such as thinking of saying "might" or "probably," it is immediately intercepted, triggering immediate verification behavior (categorized into L1/L2/L3 actions).
   • P1 (Proactiveness): Drives the Agent to propose actions daily, ask for feedback on task results, and anticipate problems.
   • P2 (Instant Introspection): After every task completion or correction, the Agent immediately conducts introspection and writes findings to .learnings/ files, rather than waiting for a fixed schedule.
   • Other Rules: Cover multiple dimensions including emotion perception, communication simplification, and proactive reporting of capability gaps.

3. Automated Memory Formation
   The skill defines five clear "signals" (e.g., user correction, dissatisfaction with results, stating new rules). When these signals are detected, they automatically trigger the Agent to record relevant information into MEMORY.md or .learnings/ files, creating persistent memory assets that can be invoked by subsequent sessions.

Key Implementation Steps

The application process is entirely conversation-driven, requiring no scripts. After installation, telling the AI to apply the skill causes it to automatically:
1. Write all the above evolution rules and checkpoint logic into SOUL.md.
2. Create necessary template file structures like .learnings/.
3. From then on, the Agent's behavior operates under this self-auditing and evolution framework.

Scope of Application and Considerations

• Dependency on Framework Configuration: This skill works by injecting rules into the Agent's configuration file (e.g., SOUL.md). Therefore, it requires the target AI Agent framework to support similar persistent personality/rule file configurations. It is applicable to OpenClaw and other Agent frameworks that can write rules to their configuration.
• Behavioral Guidance, Not Model Training: The skill's role is to guide and standardize the Agent's external behavior and interaction patterns, making them align with the human-desired "self-evolution" mode. It does not change the underlying large model's capabilities or knowledge, but optimizes its output generation strategy and internal decision-making processes.
• Dependent on High-Quality Input: Its effectiveness heavily relies on the "boss" (user) providing clear and timely feedback. The quality of feedback directly determines the depth and accuracy of the Agent's introspection and memory formation.
• Requires Active Cooperation: The Agent needs to strictly adhere to the written rules (e.g., "Uncertain → Verify Immediately") to maximize effectiveness. This necessitates establishing a new interaction contract during usage.