Pattern Recognition

Identifies, learns, and applies patterns from operations, errors, and resources to generate templates, analyze efficiency, and suggest optimizations.

Security Scan

The skill's code and instructions are internally consistent with its stated purpose (learning from operations, errors, and resources) and do not request unrelated credentials or network access, though it will read and write files in the agent workspace which you should review before enabling.

Purpose & Capability

The name/description match the included Python scripts: both learner and analyzer operate on operation history, logs, and metrics. One minor inconsistency: SKILL.md shows CLI usage (pattern ...) but no install spec or CLI wrapper is provided in the package — the repo contains Python scripts but not an installed 'pattern' command. Functionality requested (reading workspace markdown/log/metrics) is aligned with the stated purpose.

Instruction Scope

Runtime instructions and the scripts read files under /home/openclaw/.openclaw/workspace (memory/*.md, logs/*.log, metrics/*.json) and write patterns/suggestions/logs back into a patterns directory. This is appropriate for pattern-learning but means the skill will process potentially sensitive agent memory and logs; there are no network calls or external endpoints in the code.

Install Mechanism

No install spec (instruction-only) and only two Python scripts are included. This is low-risk from an install standpoint because nothing is downloaded or extracted from external URLs.

Credentials

The skill requests no environment variables or external credentials. It hardcodes a workspace path (/home/openclaw/.openclaw/workspace) which is reasonable for an agent-local analysis tool but gives it access to whatever lives in that workspace.

Persistence & Privilege

always is false and the skill does not modify other skills or global agent settings. It persists learned state and logs under the workspace patterns directory only.

Assessment

This skill appears to do what it says: it scans the agent workspace for operations, logs, and metrics and writes learned patterns and suggestions back to a patterns folder. Before installing, review the contents of /home/openclaw/.openclaw/workspace (memory, logs, metrics) to ensure no sensitive secrets or credentials would be processed or exposed. Note there is no network/exfiltration code in the included scripts, but the SKILL.md references a 'pattern' CLI that isn't provided — verify how the skill will be invoked in your environment (you may need to run the Python scripts directly or provide a wrapper). If you want a safer test, run the scripts in a sandboxed environment with sample data first.

Pattern Recognition Skill

Overview

Advanced pattern recognition and learning system for OpenClaw.

Description

This skill identifies, learns, and applies patterns in operations, errors, and workflows.

Features

• Pattern learning from operations
• Template generation
• Efficiency analysis
• Optimization suggestions

Usage

Learn Patterns

# Learn from recent operations
pattern learn --source operations --days 7

# Learn from error logs
pattern learn --source errors --days 7

# Learn from resource usage
pattern learn --source resources --days 7

Generate Templates

# Create documentation template
pattern template --type documentation --source backlog/BL-*

# Create fix template
pattern template --type fix --source scripts/*.sh

# Create workflow template
pattern template --type workflow --source memory/tasks/*

Analyze Efficiency

# Analyze operation patterns
pattern analyze --type operations --days 7

# Analyze resource usage
pattern analyze --type resources --days 7

# Analyze workflow patterns
pattern analyze --type workflows --days 7

Get Suggestions

# Get optimization suggestions
pattern suggest --type optimization

# Get batching suggestions
pattern suggest --type batching

# Get template suggestions
pattern suggest --type templates

Components

1. Pattern Learner

class PatternLearner:
    """Learn patterns from operations and logs."""
    
    def learn_from_operations(self):
        """Learn from operation history."""
        pass
    
    def learn_from_errors(self):
        """Learn from error patterns."""
        pass
    
    def learn_from_resources(self):
        """Learn from resource usage."""
        pass

2. Template Generator

class TemplateGenerator:
    """Generate templates from learned patterns."""
    
    def generate_doc_template(self):
        """Generate documentation template."""
        pass
    
    def generate_fix_template(self):
        """Generate fix template."""
        pass
    
    def generate_workflow_template(self):
        """Generate workflow template."""
        pass

3. Efficiency Analyzer

class EfficiencyAnalyzer:
    """Analyze operation efficiency."""
    
    def analyze_operations(self):
        """Analyze operation patterns."""
        pass
    
    def analyze_resources(self):
        """Analyze resource usage."""
        pass
    
    def analyze_workflows(self):
        """Analyze workflow patterns."""
        pass

Installation

# Install skill
clawhub install pattern-recognition

# Initialize databases
pattern init

# Start learning system
pattern start

Configuration

pattern_recognition:
  learning:
    enabled: true
    interval: 3600  # seconds
    sources:
      - operations
      - errors
      - resources
  
  templates:
    auto_generate: true
    types:
      - documentation
      - fixes
      - workflows
  
  analysis:
    enabled: true
    interval: 86400  # daily
    metrics:
      - efficiency
      - batching
      - resources

Integration

integrations:
  memory:
    - Pattern storage
    - Template cache
    - Analysis results
  
  watchtower:
    - Efficiency reports
    - Optimization suggestions
    - Template updates
  
  agents:
    knox:
      - Code patterns
      - Fix templates
    scout:
      - Research patterns
      - Analysis templates
    marcus:
      - Cost patterns
      - Resource templates

Updates

2026-03-24:

• Created skill
• Added core components
• Implemented learning system
• Added integration points