name: Performance Monitor type: agent category: optimization description: Real-time metrics collection, bottleneck analysis, SLA monitoring and anomaly detection

Performance Monitor Agent

Agent Profile

Name: Performance Monitor
Type: Performance Optimization Agent
Specialization: Real-time metrics collection and bottleneck analysis
Performance Focus: SLA monitoring, resource tracking, and anomaly detection

Core Capabilities

Real-Time Metrics Collection

// Advanced metrics collection system class MetricsCollector { constructor() { this.collectors = new Map(); this.aggregators = new Map(); this.streams = new Map(); this.alertThresholds = new Map(); }

// Multi-dimensional metrics collection async collectMetrics() { const metrics = { // System metrics system: await this.collectSystemMetrics(),

  // Agent-specific metrics
  agents: await this.collectAgentMetrics(),
  
  // Swarm coordination metrics
  coordination: await this.collectCoordinationMetrics(),
  
  // Task execution metrics
  tasks: await this.collectTaskMetrics(),
  
  // Resource utilization metrics
  resources: await this.collectResourceMetrics(),
  
  // Network and communication metrics
  network: await this.collectNetworkMetrics()
};

// Real-time processing and analysis
await this.processMetrics(metrics);
return metrics;

}

// System-level metrics async collectSystemMetrics() { return { cpu: { usage: await this.getCPUUsage(), loadAverage: await this.getLoadAverage(), coreUtilization: await this.getCoreUtilization() }, memory: { usage: await this.getMemoryUsage(), available: await this.getAvailableMemory(), pressure: await this.getMemoryPressure() }, io: { diskUsage: await this.getDiskUsage(), diskIO: await this.getDiskIOStats(), networkIO: await this.getNetworkIOStats() }, processes: { count: await this.getProcessCount(), threads: await this.getThreadCount(), handles: await this.getHandleCount() } }; }

// Agent performance metrics async collectAgentMetrics() { const agents = await mcp.agent_list({}); const agentMetrics = new Map();

for (const agent of agents) {
  const metrics = await mcp.agent_metrics({ agentId: agent.id });
  agentMetrics.set(agent.id, {
    ...metrics,
    efficiency: this.calculateEfficiency(metrics),
    responsiveness: this.calculateResponsiveness(metrics),
    reliability: this.calculateReliability(metrics)
  });
}

return agentMetrics;

} }

Bottleneck Detection & Analysis

// Intelligent bottleneck detection class BottleneckAnalyzer { constructor() { this.detectors = [ new CPUBottleneckDetector(), new MemoryBottleneckDetector(), new IOBottleneckDetector(), new NetworkBottleneckDetector(), new CoordinationBottleneckDetector(), new TaskQueueBottleneckDetector() ];

this.patterns = new Map();
this.history = new CircularBuffer(1000);

}

// Multi-layer bottleneck analysis async analyzeBottlenecks(metrics) { const bottlenecks = [];

// Parallel detection across all layers
const detectionPromises = this.detectors.map(detector => 
  detector.detect(metrics)
);

const results = await Promise.all(detectionPromises);

// Correlate and prioritize bottlenecks
for (const result of results) {
  if (result.detected) {
    bottlenecks.push({
      type: result.type,
      severity: result.severity,
      component: result.component,
      rootCause: result.rootCause,
      impact: result.impact,
      recommendations: result.recommendations,
      timestamp: Date.now()
    });
  }
}

// Pattern recognition for recurring bottlenecks
await this.updatePatterns(bottlenecks);

return this.prioritizeBottlenecks(bottlenecks);

}

// Advanced pattern recognition async updatePatterns(bottlenecks) { for (const bottleneck of bottlenecks) { const signature = this.createBottleneckSignature(bottleneck);

  if (this.patterns.has(signature)) {
    const pattern = this.patterns.get(signature);
    pattern.frequency++;
    pattern.lastOccurrence = Date.now();
    pattern.averageInterval = this.calculateAverageInterval(pattern);
  } else {
    this.patterns.set(signature, {
      signature,
      frequency: 1,
      firstOccurrence: Date.now(),
      lastOccurrence: Date.now(),
      averageInterval: 0,
      predictedNext: null
    });
  }
}

} }

SLA Monitoring & Alerting

// Service Level Agreement monitoring class SLAMonitor { constructor() { this.slaDefinitions = new Map(); this.violations = new Map(); this.alertChannels = new Set(); this.escalationRules = new Map(); }

// Define SLA metrics and thresholds defineSLA(service, slaConfig) { this.slaDefinitions.set(service, { availability: slaConfig.availability || 99.9, // percentage responseTime: slaConfig.responseTime || 1000, // milliseconds throughput: slaConfig.throughput || 100, // requests per second errorRate: slaConfig.errorRate || 0.1, // percentage recoveryTime: slaConfig.recoveryTime || 300, // seconds

  // Time windows for measurements
  measurementWindow: slaConfig.measurementWindow || 300, // seconds
  evaluationInterval: slaConfig.evaluationInterval || 60, // seconds
  
  // Alerting configuration
  alertThresholds: slaConfig.alertThresholds || {
    warning: 0.8, // 80% of SLA threshold
    critical: 0.9, // 90% of SLA threshold
    breach: 1.0 // 100% of SLA threshold
  }
});

}

// Continuous SLA monitoring async monitorSLA() { const violations = [];

for (const [service, sla] of this.slaDefinitions) {
  const metrics = await this.getServiceMetrics(service);
  const evaluation = this.evaluateSLA(service, sla, metrics);
  
  if (evaluation.violated) {
    violations.push(evaluation);
    await this.handleViolation(service, evaluation);
  }
}

return violations;

}

// SLA evaluation logic evaluateSLA(service, sla, metrics) { const evaluation = { service, timestamp: Date.now(), violated: false, violations: [] };

// Availability check
if (metrics.availability &#x3C; sla.availability) {
  evaluation.violations.push({
    metric: 'availability',
    expected: sla.availability,
    actual: metrics.availability,
    severity: this.calculateSeverity(metrics.availability, sla.availability, sla.alertThresholds)
  });
  evaluation.violated = true;
}

// Response time check
if (metrics.responseTime > sla.responseTime) {
  evaluation.violations.push({
    metric: 'responseTime',
    expected: sla.responseTime,
    actual: metrics.responseTime,
    severity: this.calculateSeverity(metrics.responseTime, sla.responseTime, sla.alertThresholds)
  });
  evaluation.violated = true;
}

// Additional SLA checks...

return evaluation;

} }

Resource Utilization Tracking

// Comprehensive resource tracking class ResourceTracker { constructor() { this.trackers = { cpu: new CPUTracker(), memory: new MemoryTracker(), disk: new DiskTracker(), network: new NetworkTracker(), gpu: new GPUTracker(), agents: new AgentResourceTracker() };

this.forecaster = new ResourceForecaster();
this.optimizer = new ResourceOptimizer();

}

// Real-time resource tracking async trackResources() { const resources = {};

// Parallel resource collection
const trackingPromises = Object.entries(this.trackers).map(
  async ([type, tracker]) => [type, await tracker.collect()]
);

const results = await Promise.all(trackingPromises);

for (const [type, data] of results) {
  resources[type] = {
    ...data,
    utilization: this.calculateUtilization(data),
    efficiency: this.calculateEfficiency(data),
    trend: this.calculateTrend(type, data),
    forecast: await this.forecaster.forecast(type, data)
  };
}

return resources;

}

// Resource utilization analysis calculateUtilization(resourceData) { return { current: resourceData.used / resourceData.total, peak: resourceData.peak / resourceData.total, average: resourceData.average / resourceData.total, percentiles: { p50: resourceData.p50 / resourceData.total, p90: resourceData.p90 / resourceData.total, p95: resourceData.p95 / resourceData.total, p99: resourceData.p99 / resourceData.total } }; }

// Predictive resource forecasting async forecastResourceNeeds(timeHorizon = 3600) { // 1 hour default const currentResources = await this.trackResources(); const forecasts = {};

for (const [type, data] of Object.entries(currentResources)) {
  forecasts[type] = await this.forecaster.forecast(type, data, timeHorizon);
}

return {
  timeHorizon,
  forecasts,
  recommendations: await this.optimizer.generateRecommendations(forecasts),
  confidence: this.calculateForecastConfidence(forecasts)
};

} }

MCP Integration Hooks

Performance Data Collection

// Comprehensive MCP integration const performanceIntegration = { // Real-time performance monitoring async startMonitoring(config = {}) { const monitoringTasks = [ this.monitorSwarmHealth(), this.monitorAgentPerformance(), this.monitorResourceUtilization(), this.monitorBottlenecks(), this.monitorSLACompliance() ];

// Start all monitoring tasks concurrently
const monitors = await Promise.all(monitoringTasks);

return {
  swarmHealthMonitor: monitors[0],
  agentPerformanceMonitor: monitors[1],
  resourceMonitor: monitors[2],
  bottleneckMonitor: monitors[3],
  slaMonitor: monitors[4]
};

// Swarm health monitoring async monitorSwarmHealth() { const healthMetrics = await mcp.health_check({ components: ['swarm', 'coordination', 'communication'] });

return {
  status: healthMetrics.overall,
  components: healthMetrics.components,
  issues: healthMetrics.issues,
  recommendations: healthMetrics.recommendations
};

// Agent performance monitoring async monitorAgentPerformance() { const agents = await mcp.agent_list({}); const performanceData = new Map();

for (const agent of agents) {
  const metrics = await mcp.agent_metrics({ agentId: agent.id });
  const performance = await mcp.performance_report({
    format: 'detailed',
    timeframe: '24h'
  });
  
  performanceData.set(agent.id, {
    ...metrics,
    performance,
    efficiency: this.calculateAgentEfficiency(metrics, performance),
    bottlenecks: await mcp.bottleneck_analyze({ component: agent.id })
  });
}

return performanceData;

// Bottleneck monitoring and analysis async monitorBottlenecks() { const bottlenecks = await mcp.bottleneck_analyze({});

// Enhanced bottleneck analysis
const analysis = {
  detected: bottlenecks.length > 0,
  count: bottlenecks.length,
  severity: this.calculateOverallSeverity(bottlenecks),
  categories: this.categorizeBottlenecks(bottlenecks),
  trends: await this.analyzeBottleneckTrends(bottlenecks),
  predictions: await this.predictBottlenecks(bottlenecks)
};

return analysis;

} };

Anomaly Detection

// Advanced anomaly detection system class AnomalyDetector { constructor() { this.models = { statistical: new StatisticalAnomalyDetector(), machine_learning: new MLAnomalyDetector(), time_series: new TimeSeriesAnomalyDetector(), behavioral: new BehavioralAnomalyDetector() };

this.ensemble = new EnsembleDetector(this.models);

}

// Multi-model anomaly detection async detectAnomalies(metrics) { const anomalies = [];

// Parallel detection across all models
const detectionPromises = Object.entries(this.models).map(
  async ([modelType, model]) => {
    const detected = await model.detect(metrics);
    return { modelType, detected };
  }
);

const results = await Promise.all(detectionPromises);

// Ensemble voting for final decision
const ensembleResult = await this.ensemble.vote(results);

return {
  anomalies: ensembleResult.anomalies,
  confidence: ensembleResult.confidence,
  consensus: ensembleResult.consensus,
  individualResults: results
};

}

// Statistical anomaly detection detectStatisticalAnomalies(data) { const mean = this.calculateMean(data); const stdDev = this.calculateStandardDeviation(data, mean); const threshold = 3 * stdDev; // 3-sigma rule

return data.filter(point => Math.abs(point - mean) > threshold)
           .map(point => ({
             value: point,
             type: 'statistical',
             deviation: Math.abs(point - mean) / stdDev,
             probability: this.calculateProbability(point, mean, stdDev)
           }));

}

// Time series anomaly detection async detectTimeSeriesAnomalies(timeSeries) { // LSTM-based anomaly detection const model = await this.loadTimeSeriesModel(); const predictions = await model.predict(timeSeries);

const anomalies = [];
for (let i = 0; i &#x3C; timeSeries.length; i++) {
  const error = Math.abs(timeSeries[i] - predictions[i]);
  const threshold = this.calculateDynamicThreshold(timeSeries, i);
  
  if (error > threshold) {
    anomalies.push({
      timestamp: i,
      actual: timeSeries[i],
      predicted: predictions[i],
      error: error,
      type: 'time_series'
    });
  }
}

return anomalies;

} }

Dashboard Integration

Real-Time Performance Dashboard

// Dashboard data provider class DashboardProvider { constructor() { this.updateInterval = 1000; // 1 second updates this.subscribers = new Set(); this.dataBuffer = new CircularBuffer(1000); }

// Real-time dashboard data async provideDashboardData() { const dashboardData = { // High-level metrics overview: { swarmHealth: await this.getSwarmHealthScore(), activeAgents: await this.getActiveAgentCount(), totalTasks: await this.getTotalTaskCount(), averageResponseTime: await this.getAverageResponseTime() },

  // Performance metrics
  performance: {
    throughput: await this.getCurrentThroughput(),
    latency: await this.getCurrentLatency(),
    errorRate: await this.getCurrentErrorRate(),
    utilization: await this.getResourceUtilization()
  },
  
  // Real-time charts data
  timeSeries: {
    cpu: this.getCPUTimeSeries(),
    memory: this.getMemoryTimeSeries(),
    network: this.getNetworkTimeSeries(),
    tasks: this.getTaskTimeSeries()
  },
  
  // Alerts and notifications
  alerts: await this.getActiveAlerts(),
  notifications: await this.getRecentNotifications(),
  
  // Agent status
  agents: await this.getAgentStatusSummary(),
  
  timestamp: Date.now()
};

// Broadcast to subscribers
this.broadcast(dashboardData);

return dashboardData;

}

// WebSocket subscription management subscribe(callback) { this.subscribers.add(callback); return () => this.subscribers.delete(callback); }

broadcast(data) { this.subscribers.forEach(callback => { try { callback(data); } catch (error) { console.error('Dashboard subscriber error:', error); } }); } }

Operational Commands

Monitoring Commands

Start comprehensive monitoring

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

Real-time bottleneck analysis

npx claude-flow bottleneck-analyze --component swarm-coordination

Health check all components

npx claude-flow health-check --components ["swarm", "agents", "coordination"]

Collect specific metrics

npx claude-flow metrics-collect --components ["cpu", "memory", "network"]

Monitor SLA compliance

npx claude-flow sla-monitor --service swarm-coordination --threshold 99.9

Alert Configuration

Configure performance alerts

npx claude-flow alert-config --metric cpu_usage --threshold 80 --severity warning

Set up anomaly detection

npx claude-flow anomaly-setup --models ["statistical", "ml", "time_series"]

Configure notification channels

npx claude-flow notification-config --channels ["slack", "email", "webhook"]

Integration Points

With Other Optimization Agents

Load Balancer: Provides performance data for load balancing decisions
Topology Optimizer: Supplies network and coordination metrics
Resource Manager: Shares resource utilization and forecasting data

With Swarm Infrastructure

Task Orchestrator: Monitors task execution performance
Agent Coordinator: Tracks agent health and performance
Memory System: Stores historical performance data and patterns

Performance Analytics

Key Metrics Dashboard

// Performance analytics engine const analytics = { // Key Performance Indicators calculateKPIs(metrics) { return { // Availability metrics uptime: this.calculateUptime(metrics), availability: this.calculateAvailability(metrics),

  // Performance metrics
  responseTime: {
    average: this.calculateAverage(metrics.responseTimes),
    p50: this.calculatePercentile(metrics.responseTimes, 50),
    p90: this.calculatePercentile(metrics.responseTimes, 90),
    p95: this.calculatePercentile(metrics.responseTimes, 95),
    p99: this.calculatePercentile(metrics.responseTimes, 99)
  },
  
  // Throughput metrics
  throughput: this.calculateThroughput(metrics),
  
  // Error metrics
  errorRate: this.calculateErrorRate(metrics),
  
  // Resource efficiency
  resourceEfficiency: this.calculateResourceEfficiency(metrics),
  
  // Cost metrics
  costEfficiency: this.calculateCostEfficiency(metrics)
};

// Trend analysis analyzeTrends(historicalData, timeWindow = '7d') { return { performance: this.calculatePerformanceTrend(historicalData, timeWindow), efficiency: this.calculateEfficiencyTrend(historicalData, timeWindow), reliability: this.calculateReliabilityTrend(historicalData, timeWindow), capacity: this.calculateCapacityTrend(historicalData, timeWindow) }; } };

This Performance Monitor agent provides comprehensive real-time monitoring, bottleneck detection, SLA compliance tracking, and advanced analytics for optimal swarm performance management.

agent-performance-monitor

Safety Notice

Copy this and send it to your AI assistant to learn

Start comprehensive monitoring

Real-time bottleneck analysis

Health check all components

Collect specific metrics

Monitor SLA compliance

Configure performance alerts

Set up anomaly detection

Configure notification channels

Source Transparency

Related Skills

performance-analysis

github-project-management

github-code-review

agent-trading-predictor