Self-Challenge Mechanism

Description

A self-evolution skill based on Agent0 paper (arXiv:2511.16043). Uses a dual-agent competition model where Curriculum Agent designs challenges and Executor Agent attempts them, driving continuous capability expansion.

Activation Keywords

自我挑战
self challenge
能力测试
capability test
自我进化测试
self evolution test
挑战任务
challenge task
agent0 挑战

Recommended Model

sonnet4.5 (Recommended for complex reasoning and challenge design)

Tools Used

exec: Execute commands and scripts
read: Read existing skills, documentation, and resources
write: Create challenge results and new skills
memory_search: Find relevant knowledge for challenges
sessions_spawn: Spawn sub-agents for execution

Usage Patterns

Start Challenge

开始自我挑战

Specific Domain Challenge

挑战我的 [domain] 能力

Weekly Challenge

本周自我挑战

Instructions for Agents

Overview

The self-challenge mechanism uses dual-agent architecture:

┌─────────────────────────────────────────────────────────┐
│            Self-Challenge Architecture                   │
├─────────────────────────────────────────────────────────┤
│                                                          │
│   ┌─────────────────┐       ┌─────────────────┐         │
│   │   Curriculum    │       │    Executor     │         │
│   │     Agent       │──────▶│     Agent       │         │
│   │  (设计挑战)      │       │   (执行挑战)    │         │
│   └─────────────────┘       └─────────────────┘         │
│          │                          │                    │
│          │                          │                    │
│          ▼                          ▼                    │
│   ┌─────────────────────────────────────────────┐       │
│   │              Review & Learn                  │       │
│   │         (回顾总结，提取经验)                   │       │
│   └─────────────────────────────────────────────┘       │
│                     │                                    │
│                     ▼                                    │
│   ┌─────────────────────────────────────────────┐       │
│   │           Knowledge Update                   │       │
│   │   (更新 skills, MEMORY.md, 工作流程)          │       │
│   └─────────────────────────────────────────────┘       │
│                                                          │
└─────────────────────────────────────────────────────────┘

Phase 1: Curriculum Agent (设计挑战)

Role: Design challenges that are slightly above current capabilities

Challenge Selection Criteria:

Capability Gap: Identify weak areas from recent performance
Difficulty: Should be achievable but challenging
Learning Value: Must provide actionable insights
Relevance: Align with user needs and goals

Challenge Types:

Type	Description	Example
Tool Mastery	Learn to use a new tool	Use a new CLI tool to complete a task
Integration	Combine multiple tools	Create workflow combining 3+ tools
Problem Solving	Solve complex problems	Debug and fix a failing system
Knowledge Synthesis	Create new knowledge	Write a comprehensive guide
Automation	Automate repetitive tasks	Create a cron-based workflow

Challenge Design Process:

Analyze Recent Performance

def analyze_capability_gaps():
    # Review recent self-reflection reports
    recent_reviews = read_recent_reviews()
    
    # Identify weak areas
    weak_areas = []
    for review in recent_reviews:
        if review.rating < 4:
            weak_areas.append(review.area)
    
    # Check for missing skills
    existing_skills = list_skills()
    recommended_skills = get_recommended_skills()
    missing_skills = set(recommended_skills) - set(existing_skills)
    
    return {
        'weak_areas': weak_areas,
        'missing_skills': missing_skills,
        'improvement_opportunities': identify_opportunities()
    }

Select Challenge Domain

def select_challenge_domain(gaps):
    # Prioritize by impact
    priorities = [
        ('weak_area', gaps.weak_areas),
        ('missing_skill', gaps.missing_skills),
        ('opportunity', gaps.improvement_opportunities)
    ]
    
    for priority_type, items in priorities:
        if items:
            return {
                'type': priority_type,
                'domain': items[0],
                'difficulty': 'medium'
            }

Design Specific Challenge

## Challenge: [Name]

### Domain
[Capability area being tested]

### Difficulty
[Easy/Medium/Hard]

### Objective
[Clear, measurable goal]

### Constraints
- Time limit: [duration]
- Tools allowed: [list]
- Success criteria: [measurable]

### Expected Learning
- [What will be learned]
- [How it improves capabilities]

### Resources
- [Available references]
- [Similar challenges solved]

Phase 2: Executor Agent (执行挑战)

Role: Attempt to complete the designed challenge

Execution Process:

Understand Challenge
- Read challenge specification
- Identify required resources
- Plan approach
Execute
- Follow systematic approach
- Document each step
- Track time and resources

Document Results

## Challenge Execution Log

### Start Time
[timestamp]

### Approach
1. [Step 1]
2. [Step 2]
3. [Step 3]

### Obstacles Encountered
| Obstacle | Attempted Solution | Result |
|----------|-------------------|--------|
| [issue] | [solution] | [outcome] |

### End Time
[timestamp]

### Outcome
[Success/Partial Success/Failure]

### Key Learnings
- [Learning 1]
- [Learning 2]

Phase 3: Review & Learn (回顾总结)

Role: Analyze results and extract actionable knowledge

Review Process:

Outcome Analysis

def analyze_outcome(challenge, execution_log):
    success_rate = calculate_success_rate(execution_log)
    time_efficiency = calculate_time_efficiency(challenge, execution_log)
    resource_efficiency = calculate_resource_efficiency(execution_log)
    
    return {
        'success_rate': success_rate,
        'time_efficiency': time_efficiency,
        'resource_efficiency': resource_efficiency,
        'overall_score': (success_rate + time_efficiency + resource_efficiency) / 3
    }

Capability Assessment

## Capability Assessment

### Before Challenge
| Capability | Level |
|------------|-------|
| [skill 1] | [1-5] |
| [skill 2] | [1-5] |

### After Challenge
| Capability | Level | Change |
|------------|-------|--------|
| [skill 1] | [1-5] | [↑/↓/=] |
| [skill 2] | [1-5] | [↑/↓/=] |

Knowledge Extraction
- What worked well?
- What didn't work?
- What new skills were developed?
- What should be documented?
Update Knowledge Base
- Update MEMORY.md with learnings
- Create or update skills
- Add to learned-skills.md
- Schedule follow-up challenges

Challenge Templates

Template 1: Tool Mastery

## Challenge: Master [Tool Name]

### Objective
Use [tool] to complete [specific task] with [success criteria]

### Constraints
- Time: 30 minutes
- Resources: Official docs, examples
- Success: Task completed without errors

### Steps
1. Read documentation
2. Set up environment
3. Execute basic commands
4. Complete target task
5. Document learnings

Template 2: Integration Challenge

## Challenge: Integrate [Tools]

### Objective
Create a workflow that combines [tool1], [tool2], [tool3]

### Constraints
- Time: 60 minutes
- Must use all 3 tools
- Must solve real problem
- Success: Working workflow documented

### Steps
1. Identify integration points
2. Design workflow
3. Implement and test
4. Document and share

Template 3: Problem Solving

## Challenge: Solve [Problem]

### Objective
Debug and fix [failing system/error]

### Constraints
- Time: 45 minutes
- Must identify root cause
- Must implement fix
- Success: System working correctly

### Steps
1. Reproduce issue
2. Analyze logs/errors
3. Identify root cause
4. Implement fix
5. Verify solution
6. Document process

Context Files

~/.openclaw/workspace/memory/self-reflection/*.md

Recent self-reflection reports for identifying capability gaps.

~/.openclaw/workspace/knowledge/skills/learned-skills.md

Skills to be updated after challenges.

~/.openclaw/workspace/MEMORY.md

Long-term memory for storing challenge learnings.

~/.openclaw/workspace/memory/challenge-log.json

Log of all challenges executed.

{
  "challenges": [
    {
      "id": "challenge-001",
      "date": "2026-03-05",
      "domain": "tool-mastery",
      "difficulty": "medium",
      "outcome": "success",
      "score": 0.85,
      "learnings": ["..."]
    }
  ]
}

Scheduling

Recommended Schedule

Weekly Challenge: Every Monday 10:00 AM
Duration: 30-60 minutes
Follow-up: Review results within 24 hours

Cron Configuration

openclaw cron add \
  --name "self-challenge" \
  --description "Weekly self-challenge for capability expansion" \
  --cron "0 10 * * 1" \
  --tz "Asia/Shanghai" \
  --system-event "执行自我挑战任务"

Error Handling

Challenge Too Easy

If challenge completed in < 50% of allotted time:
  1. Increase difficulty for next challenge
  2. Add additional constraints
  3. Expand scope

Challenge Too Hard

If challenge failed completely:
  1. Break down into smaller challenges
  2. Provide more resources
  3. Adjust difficulty level
  4. Reschedule with better preparation

Resource Unavailable

If required resources are unavailable:
  1. Find alternative resources
  2. Modify challenge to use available resources
  3. Postpone and acquire resources

Examples

Example 1: Tool Mastery Challenge

User: "开始自我挑战"

Agent (Curriculum):
## Challenge: Master openclaw cron Commands

### Domain
Tool Mastery - OpenClaw CLI

### Difficulty
Medium

### Objective
Create, list, and manage 3 different cron jobs using openclaw CLI

### Constraints
- Time: 30 minutes
- Resources: openclaw docs, --help
- Success: 3 jobs created, listed, one executed

### Expected Learning
- Understanding of openclaw cron system
- Job scheduling best practices
- Error handling for cron jobs

---

Agent (Executor):
## Execution Log

### Start: 2026-03-05 11:00
### Approach:
1. Read openclaw cron --help
2. Create first job (daily)
3. Create second job (weekly)
4. Create third job (hourly)
5. List all jobs
6. Run one job immediately

### Obstacles:
| Obstacle | Solution | Result |
|----------|----------|--------|
| Unknown syntax | Used --help | Success |
| Timezone issue | Set tz explicitly | Success |

### End: 2026-03-05 11:25
### Outcome: Success (25 minutes)

### Key Learnings:
1. openclaw cron add syntax
2. Cron expression format
3. Timezone configuration importance

---

Agent (Review):
## Review Results

### Scores:
- Success Rate: 100%
- Time Efficiency: 83% (25/30 min)
- Overall: 92%

### Capability Change:
| Capability | Before | After |
|------------|--------|-------|
| openclaw cron | 2 | 4 ↑ |

### Knowledge Updates:
- Updated: learned-skills.md (new skill entry)
- Created: knowledge/topics/optimization/cron-jobs.md

### Next Challenge Suggestion:
Automate cron job monitoring and alerting

Best Practices

Progressive Difficulty: Start easy, increase difficulty over time
Document Everything: Log all attempts, successes, and failures
Real Problems: Design challenges around actual user needs
Time Bound: Always set reasonable time limits
Review Promptly: Analyze results within 24 hours
Iterate: Use learnings to improve future challenges

Limitations

Requires honest self-assessment
Challenge design quality affects learning value
May not cover all capability gaps
Time investment needed for proper execution
Benefits accumulate over time with consistency

Success Metrics

Metric	Target	Measurement
Challenge Completion Rate	> 70%	Completed / Attempted
Capability Improvement	> 0.5/week	Average skill level change
Knowledge Creation	> 1/week	New skills or docs created
Time Efficiency	> 75%	Actual time / Allocated time

Resources

Source Paper: https://arxiv.org/abs/2511.16043
Self-Reflection Reports: ~/.openclaw/workspace/memory/self-reflection/
Challenge Log: ~/.openclaw/workspace/memory/challenge-log.json

Related Skills

ice-review: Review challenges using ICE method
memory-retrieval: Find relevant knowledge for challenges
skill-extractor: Extract skills from challenge learnings

Notes

Self-challenge is most effective when scheduled regularly
Mix different challenge types for balanced development
Celebrate successes to maintain motivation
Don't fear failures - they provide learning opportunities
Track progress over time to see improvement