Performance Analyzer Skill

Overview

This skill specializes in identifying and resolving performance bottlenecks in development workflows, agent coordination, and system operations. It provides comprehensive analysis, pattern recognition, and actionable recommendations.

When to Use

Analyzing slow execution times in workflows
Identifying resource constraints (CPU, memory, I/O)
Detecting coordination overhead in agent systems
Finding parallelization opportunities
Root cause analysis for performance issues
Generating optimization recommendations

Quick Start

# Run bottleneck analysis
npx claude-flow bottleneck-analyze --component swarm-coordination

# Generate performance report
npx claude-flow performance-report --format detailed --timeframe 24h

# Collect metrics for analysis
npx claude-flow metrics-collect --components ["cpu", "memory", "network"]

# Trend analysis
npx claude-flow trend-analysis --metric performance --period 7d

Architecture

+-----------------------------------------------------------+
|                  Performance Analyzer                      |
+-----------------------------------------------------------+
|  Data Collector  |  Pattern Analyzer  |  Recommender      |
+------------------+--------------------+-------------------+
         |                  |                    |
         v                  v                    v
+----------------+  +------------------+  +------------------+
| Metrics        |  | Bottleneck Types |  | Strategies       |
| - Execution    |  | - Execution Time |  | - Parallelization|
| - Resources    |  | - Resources      |  | - Reallocation   |
| - Dependencies |  | - Coordination   |  | - Algorithm      |
| - Communication|  | - Sequential     |  | - Caching        |
+----------------+  | - Data Transfer  |  | - Topology       |
                    +------------------+  +------------------+
         |                  |                    |
         v                  v                    v
+-----------------------------------------------------------+
|              Report Generator & Action Plan                |
+-----------------------------------------------------------+

Bottleneck Types

Type	Symptoms	Detection Method
Execution Time	Tasks taking longer than expected	Timing analysis
Resource Constraints	CPU/memory/I/O at limits	Resource monitoring
Coordination Overhead	Inefficient agent communication	Message analysis
Sequential Blockers	Unnecessary serial execution	Dependency mapping
Data Transfer	Large payload movements	Network analysis

Analysis Workflow

1. Data Collection Phase

// Comprehensive data collection
const dataCollection = {
  async collect(swarmId, duration = 60000) {
    const metrics = await Promise.all([
      this.gatherExecutionMetrics(swarmId),
      this.profileResourceUsage(swarmId),
      this.mapTaskDependencies(swarmId),
      this.traceCommunicationPatterns(swarmId),
      this.identifyHotspots(swarmId)
    ]);

    return {
      execution: metrics[0],
      resources: metrics[1],
      dependencies: metrics[2],
      communication: metrics[3],
      hotspots: metrics[4],
      timestamp: Date.now()
    };
  }
};

2. Analysis Phase

// Multi-dimensional analysis
const analysis = {
  async analyze(data, baselines) {
    return {
      // Compare against baselines
      comparison: this.compareAgainstBaselines(data, baselines),

      // Identify anomalies
      anomalies: this.identifyAnomalies(data),

      // Correlate metrics
      correlations: this.correlateMetrics(data),

      // Determine root causes
      rootCauses: await this.determineRootCauses(data),

      // Prioritize issues
      prioritizedIssues: this.prioritizeIssues(data)
    };
  }
};

3. Recommendation Phase

// Generate actionable recommendations
const recommendations = {
  async generate(analysis) {
    return {
      optimizations: this.generateOptimizationOptions(analysis),
      improvements: this.estimateImprovementPotential(analysis),
      effort: this.assessImplementationEffort(analysis),
      actionPlan: this.createActionPlan(analysis),
      successMetrics: this.defineSuccessMetrics(analysis)
    };
  }
};

Common Bottleneck Patterns

1. Single Agent Overload

Symptoms: One agent handling complex tasks alone Detection: Agent utilization > 90%, queue depth growing Solution: Spawn specialized agents for parallel work Expected Improvement: 40-60%

2. Sequential Task Chain

Symptoms: Tasks waiting unnecessarily Detection: Low parallelization ratio, high wait times Solution: Identify parallelization opportunities Expected Improvement: 30-50%

3. Resource Starvation

Symptoms: Agents waiting for resources Detection: Resource contention, lock waits Solution: Increase limits or optimize usage Expected Improvement: 20-40%

4. Communication Overhead

Symptoms: Excessive inter-agent messages Detection: High message count, latency spikes Solution: Batch operations or change topology Expected Improvement: 25-45%

5. Inefficient Algorithms

Symptoms: High complexity operations Detection: O(n^2) patterns, memory pressure Solution: Algorithm optimization or caching Expected Improvement: 50-80%

Key Performance Indicators

KPI	Description	Target
Task Execution Time	Average, P95, P99	< baseline * 1.1
Resource Utilization	CPU, Memory, I/O	60-80% optimal
Parallelization Ratio	Parallel vs Sequential	> 0.7
Agent Efficiency	Task throughput per agent	> baseline
Communication Latency	Message delays	< 50ms

MCP Integration

// Performance analysis integration
const performanceIntegration = {
  // Comprehensive bottleneck analysis
  async analyzeBottlenecks(component = null) {
    const [bottlenecks, metrics, trends] = await Promise.all([
      mcp.bottleneck_analyze({ component }),
      mcp.metrics_collect({ components: ['system', 'agents', 'coordination'] }),
      mcp.trend_analysis({ metric: 'performance', period: '24h' })
    ]);

    return {
      bottlenecks,
      metrics,
      trends,
      analysis: this.synthesizeAnalysis(bottlenecks, metrics, trends)
    };
  },

  // Generate performance report
  async generateReport(format = 'detailed') {
    const [performance, usage, errors] = await Promise.all([
      mcp.performance_report({ format, timeframe: '24h' }),
      mcp.usage_stats({}),
      mcp.error_analysis({})
    ]);

    return { performance, usage, errors };
  }
};

Report Format

## Performance Analysis Report

### Executive Summary
- Overall performance score: 78/100
- Critical bottlenecks identified: 2
- Recommended actions: 5

### Detailed Findings

#### 1. Sequential Task Execution
- **Impact**: High (40% of execution time)
- **Root Cause**: Tasks A, B, C running sequentially without dependencies
- **Recommendation**: Parallelize tasks A, B, C
- **Expected Improvement**: 35%

#### 2. Memory Pressure
- **Impact**: Medium (25% of issues)
- **Root Cause**: Large file operations loading entire files
- **Recommendation**: Implement streaming processing
- **Expected Improvement**: 50% memory reduction

### Trend Analysis
- Performance over last 7 days: Declining 5%
- Improvement since last optimization: +12%
- Regression detection: None

Optimization Examples

Example 1: Slow Test Execution

Metric	Before	After	Improvement
Duration	10 min	3 min	70%
Parallelization	10%	80%	8x
Agent Utilization	25%	85%	3.4x

Solution: Parallelize test suites across multiple agents

Example 2: Agent Coordination Delay

Metric	Before	After	Improvement
Latency	150ms	90ms	40%
Messages	500/s	200/s	60% reduction
Throughput	100/s	180/s	80%

Solution: Switch from hierarchical to mesh topology

Example 3: Memory Pressure

Metric	Before	After	Improvement
Peak Memory	8GB	800MB	90%
GC Pauses	500ms	50ms	90%
Processing Time	5min	3min	40%

Solution: Stream processing instead of loading entire files

Advanced Features

1. Predictive Analysis

// ML-based bottleneck prediction
const predictiveAnalysis = {
  async predictBottlenecks(historicalData) {
    // Train model on historical patterns
    // Predict future bottlenecks
    // Recommend preemptive actions
  }
};

2. Automated Optimization

// Self-tuning optimization
const automatedOptimization = {
  async optimize(swarm, constraints) {
    // Self-tuning parameters
    // Dynamic resource allocation
    // Adaptive execution strategies
  }
};

3. A/B Testing

// Compare optimization strategies
const abTesting = {
  async compare(strategies, workload) {
    // Run strategies in parallel
    // Measure real-world impact
    // Data-driven decision
  }
};

Integration Points

Integration	Purpose
Orchestration Agents	Performance feedback, strategy suggestions
Monitoring Agents	Real-time metrics, health correlation
Optimization Agents	Handoff optimization tasks, validate results
CI/CD Pipeline	Performance gates, regression detection

Best Practices

Continuous Monitoring

Set up baseline metrics before analysis
Monitor performance trends continuously
Alert on regressions immediately
Run regular optimization cycles

Proactive Analysis

Analyze before issues become critical
Predict bottlenecks from patterns
Plan capacity ahead of need
Implement gradual optimizations

Documentation

Document all findings and actions
Track improvement over time
Share learnings across teams
Maintain optimization history

Related Skills

optimization-monitor - Real-time performance monitoring
optimization-benchmark - Performance testing and validation
optimization-load-balancer - Load distribution optimization
optimization-resources - Resource allocation
optimization-topology - Network topology optimization

Version History

1.0.0 (2026-01-02): Initial release - converted from performance-analyzer agent with bottleneck detection, pattern recognition, root cause analysis, and optimization recommendations

optimization-analyzer