Capability Evolver

Meta-skill for AI agent self-improvement. Analyzes runtime logs to detect error patterns, regressions, and inefficiencies, then generates structured improvement proposals. Use when the user or agent asks to analyze logs, diagnose failures, improve agent reliability, generate evolution proposals, or assess system health. Supports analyze, evolve, and status actions.

# Capability Evolver

**Local skill by [Claw0x](https://claw0x.com)** — runs entirely in your OpenClaw agent.

> **Runs locally.** No external API calls, no API key required. Complete privacy.

Analyze agent runtime logs, detect patterns, compute health scores, and generate structured improvement proposals. Pure deterministic logic — no LLM, no external dependencies.

## Quick Reference

| When This Happens | Use Action | What You Get |
|-------------------|------------|--------------|
| Agent keeps failing | `analyze` | Error patterns + health score |
| Same error repeats | `analyze` | Root cause identification |
| Need improvement plan | `evolve` | Prioritized recommendations |
| System health check | `status` | Health score + summary |
| Post-deployment review | `analyze` | Regression detection |
| Fleet-wide diagnostics | `analyze` (batch) | Cross-agent patterns |

**Why deterministic?** Reproducible results, no hallucination risk, sub-100ms processing, zero token costs.

---

## Prerequisites

**None.** Just install and use.

## 5-Minute Quickstart

### Step 1: Install (30 seconds)
```bash
openclaw skill add capability-evolver
```

### Step 2: Analyze Your First Logs (1 minute)
```typescript
const result = await agent.run('capability-evolver', {
  action: 'analyze',
  logs: [
    {timestamp: '2025-01-15T10:00:00Z', level: 'error', message: 'ETIMEDOUT', context: 'payment-api.ts'},
    {timestamp: '2025-01-15T10:01:00Z', level: 'error', message: 'ETIMEDOUT', context: 'payment-api.ts'},
    {timestamp: '2025-01-15T10:02:00Z', level: 'error', message: 'ETIMEDOUT', context: 'payment-api.ts'}
  ]
});
```

### Step 3: Get Actionable Insights (instant)
```json
{
  "patterns": [
    {
      "type": "repeated_error",
      "severity": "high",
      "description": "ETIMEDOUT appeared 3 times in payment-api.ts",
      "affected_contexts": ["payment-api.ts"]
    }
  ],
  "health_score": 45,
  "recommendations": [
    "Add timeout configuration to payment-api.ts",
    "Implement retry logic with exponential backoff",
    "Monitor payment API response times"
  ]
}
```

### Step 3: Generate Evolution Plan (instant)
```typescript
const evolution = await agent.run('capability-evolver', {
  action: 'evolve',
  logs: result.logs,
  strategy: 'harden'
});
```

**Done.** You now have a prioritized improvement roadmap, all processed locally.

---

## Real-World Use Cases

### Scenario 1: Production Incident Response
**Problem**: Your agent crashed in production and you need to understand why

**Solution**:
1. Export last 1000 log entries
2. Run analyze action
3. Get error patterns and cascades
4. Identify root cause in minutes

**Example**:
```typescript
const logs = await db.logs.findMany({ 
  where: { timestamp: { gte: incidentStart } },
  orderBy: { timestamp: 'asc' }
});

const analysis = await agent.run('capability-evolver', {
  action: 'analyze',
  logs: logs.map(l => ({
    timestamp: l.timestamp,
    level: l.level,
    message: l.message,
    context: l.context
  }))
});

// analysis.patterns shows: "auth-service.ts failed, then payment-api.ts failed"
// Root cause: auth service timeout cascaded to payment failures
```

### Scenario 2: Continuous Improvement Pipeline
**Problem**: You want your agent to automatically improve based on production data

**Solution**:
1. Schedule daily log analysis
2. Generate evolution proposals
3. Review and apply recommendations
4. Track improvement over time

**Example**:
```javascript
// Cron job: every day at 2am
async function dailyEvolution() {
  const logs = await getLast24HoursLogs();
  
  const evolution = await agent.run('capability-evolver', {
    action: 'evolve',
    logs,
    strategy: 'balanced'
  });
  
  // Store recommendations for review
  for (const rec of evolution.recommendations.filter(r => r.priority === 'critical')) {
    await db.recommendations.create({
      title: `${rec.category}: ${rec.description}`,
      priority: rec.priority,
      affected_files: rec.affected_files,
      approach: rec.suggested_approach
    });
  }
  
  // Track health score trend
  await db.metrics.create({
    date: new Date(),
    health_score: evolution.estimated_improvement
  });
}
// Result: Health score improved from 45 to 85 over 3 months
```

### Scenario 3: Multi-Agent Fleet Management
**Problem**: Managing 50+ agent instances, need to identify systemic issues

**Solution**:
1. Aggregate logs from all agents
2. Batch analyze to find common patterns
3. Fix once, deploy to all agents
4. Reduce fleet-wide error rate

**Example**:
```python
# Collect logs from all agents
all_logs = []
for agent_id in agent_fleet:
    logs = fetch_agent_logs(agent_id, last_24h)
    all_logs.extend(logs)

# Analyze fleet-wide
result = client.call("capability-evolver", {
    "action": "analyze",
    "logs": all_logs
})

# result.patterns shows: "40 of 50 agents failing on auth-service.ts"
# Fix auth-service.ts once, deploy to all agents
# Result: 80% reduction in fleet-wide errors
```

### Scenario 4: Pre-Deployment Health Check
**Problem**: Want to ensure new deployment doesn't introduce regressions

**Solution**:
1. Analyze logs from staging environment
2. Compare health score to production baseline
3. Block deployment if health score drops
4. Catch regressions before production

**Example**:
```javascript
// Pre-deployment health check script
async function preDeploymentCheck() {
  const stagingLogs = await fetchStagingLogs();
  
  const result = await agent.run('capability-evolver', {
    action: 'analyze',
    logs: stagingLogs
  });
  
  const BASELINE = 75;
  
  if (result.health_score < BASELINE) {
    console.error(`Health score ${result.health_score} below baseline ${BASELINE}`);
    console.error('Critical patterns:', result.patterns.filter(p => p.severity === 'critical'));
    process.exit(1);
  }
  
  console.log(`✓ Health check passed: ${result.health_score}`);
}
// Result: Zero regression-related incidents in 6 months
```

---

## Integration Recipes

### OpenClaw Agent
```typescript
// Analyze logs after each run
agent.onComplete(async () => {
  const logs = agent.getRecentLogs();
  
  const analysis = await agent.run('capability-evolver', {
    action: 'analyze',
    logs
  });
  
  if (analysis.health_score < 70) {
    console.warn('⚠️ Health score low:', analysis.health_score);
    console.log('Recommendations:', analysis.recommendations);
  }
});
```

### LangChain Agent
```python
def analyze_agent_health(logs):
    result = agent.run("capability-evolver", {
        "action": "analyze",
        "logs": logs
    })
    
    return {
        "health_score": result["health_score"],
        "patterns": result["patterns"],
        "recommendations": result["recommendations"]
    }

# Use in monitoring
health = analyze_agent_health(agent.logs)
if health["health_score"] < 70:
    alert_team(health)
```

### Custom Monitoring Dashboard
```javascript
// Real-time health monitoring
async function updateHealthDashboard() {
  const logs = await db.logs.findMany({
    where: { timestamp: { gte: Date.now() - 3600000 } } // last hour
  });
  
  const result = await agent.run('capability-evolver', {
    action: 'analyze',
    logs
  });
  
  // Update dashboard
  dashboard.update({
    healthScore: result.health_score,
    errorRate: result.summary.error_count / result.summary.total_logs,
    topPatterns: result.patterns.slice(0, 5)
  });
}

setInterval(updateHealthDashboard, 60000); // every minute
```

### Evolution Strategy Comparison
```typescript
// Compare different evolution strategies
const logs = await getProductionLogs();

const strategies = ['balanced', 'innovate', 'harden', 'repair-only'];

const results = await Promise.all(
  strategies.map