Openclaw Continuous Learning

Continuous Learning for AI Agents

An instinct-based learning system that helps AI agents improve themselves through observation and pattern detection.

What This Skill Does

• Analyzes session history - Reviews agent interactions and outputs
• Detects patterns - Identifies recurring behaviors, preferences, workflows
• Creates instincts - Atomic learnings with confidence scores
• Suggests optimizations - Based on observed behavior patterns
• Enables self-evolution - Converts insights into improvements

When to Use

Use when:

• Building self-improving AI agents
• Want agent to learn from interactions
• Discovering optimization opportunities
• Creating adaptive automation
• Tracking behavioral patterns

Skip when:

• Static, unchanging behavior preferred
• No session history available
• Simple, deterministic workflows only

Architecture

~/.openclaw/agents/ (session .jsonl files)
        │
        ▼
┌───────────────────────────────────────────┐
│ analyze.mjs                                │
│ • Reads session history                   │
│ • Extracts tool calls & errors             │
│ • Detects patterns                         │
└───────────────────────────────────────────┘
        │
        ▼
┌───────────────────────────────────────────┐
│ memory/learning/                           │
│ • instincts.jsonl (atomic learnings)       │
│ • patterns.json (aggregated)              │
│ • optimizations.json (suggestions)         │
└───────────────────────────────────────────┘

External Feedback (Sub-Skill)

This skill works with agent-self-improvement (ClawHub) for external user feedback capture:

• Internal Learning: Session analysis (this skill)
• External Learning: User feedback via SKILL:agent-self-improvement

Combined Usage

# Nightly: Internal analysis
SKILL:openclaw-continuous-learning --analyze

# After any output: Capture feedback
SKILL:agent-self-improvement --job <task> --feedback "<user response>"

# Daily: Generate combined improvements
SKILL:agent-self-improvement --improve all

Feedback Flow

User Response → agent-self-improvement → Directive Hints
        ↓
Session Analysis → openclaw-continuous-learning → Internal Patterns
        ↓
Combined Insights → Agent Optimization

Both skills store learnings in memory/learning/ and can reference each other's data.

Confidence Scoring

Confidence increases when:

• Pattern observed repeatedly
• User doesn't correct behavior
• Multiple observations agree

Confidence decreases when:

• User explicitly corrects
• Pattern not observed recently
• Contradicting evidence appears

Key Concepts

Instincts

An instinct is a small learned behavior:

id: prefer-simplicity
trigger: "when solving problems"
confidence: 0.7
domain: problem_solving
---
# Prefer Simple Solutions

## Action
Always choose the simplest solution that meets requirements.

## Evidence
- Observed preference for minimal code
- User corrected over-engineered approaches

Patterns

Aggregated observations grouped by category:

• code_style
• testing
• git
• debugging
• workflow
• communication

Optimizations

Actionable improvements derived from patterns.

Use Cases

1. Agent Self-Improvement

Agent observes its own sessions:
- What works consistently?
- What gets corrected?
- What patterns emerge?

Creates instincts → Applies high-confidence patterns

2. User Preference Learning

Learn user preferences from interactions:
- Coding style preferences
- Communication preferences
- Workflow preferences

Adapt behavior accordingly

3. Performance Optimization

Detect performance patterns:
- Slow operations
- Bottlenecks
- Optimization opportunities

Suggest improvements

4. Error Pattern Detection

Track error patterns:
- Common failures
- Resolution strategies
- Prevention approaches

Build error-handling instincts

Quick Start

# Analyze sessions (reads agent .jsonl files from ~/.openclaw/agents/)
cd ~/.openclaw/workspace/skills/openclaw-continuous-learning
node scripts/analyze.mjs

# List learned instincts
node scripts/analyze.mjs instincts

# Show optimizations
node scripts/analyze.mjs list

# Show error patterns
node scripts/analyze.mjs errors

Setup

1. Create storage directory

mkdir -p ~/.openclaw/workspace/memory/learning

2. Schedule analysis

Add to cron for periodic analysis:

{
  "id": "continuous-learning",
  "schedule": "0 22 * * *"
}

3. Integrate with daily tips

Connect to daily summary for optimization delivery.

File Structure

~/.openclaw/workspace/
└── memory/
    └── learning/
        ├── instincts.jsonl    # Atomic learnings
        ├── patterns.json      # Aggregated patterns
        └── optimizations.json # Suggestions

Example Output

🧠 Learning Report

Patterns Detected:
- prefer-simplicity (0.7) ↑2
- test-first (0.5) ↑1
- commit-often (0.3) new

Confidence Changes:
- minimal-code: 0.5 → 0.7

Suggested:
1. Prioritize simple solutions
2. Add pre-commit hooks
3. Enable stricter typing

Best Practices

1. Start simple - Few patterns, low confidence
2. Validate often - Check if patterns still hold
3. Review suggestions - Don't auto-apply everything
4. Track confidence - Update based on results
5. Export/share - Build library of common patterns

FAQ

How is this different from memory? Memory stores facts. This learns behavioral patterns and preferences.

How long to see results? Depends on session volume. Typically 1-2 weeks for meaningful patterns.

Is it safe to auto-apply? Only high-confidence (0.7+) patterns. Always review suggestions first.

Related Skills

• skill-engineer - Quality-gated skill development
• compound-engineering - Session review and learning
• memory-setup - Memory configuration
• openclaw-daily-tips - Daily optimization tips

Version: 1.1.0
Inspired by: Anthropic's continuous learning patterns, Claude Code homunculus