Performance Analysis
Profile Claude Flow swarms, find bottlenecks, and get optimization recommendations without guessing where latency or memory spikes come from.
Overview
Performance Analysis is an agent skill most often used in Operate (also Ship) that profiles Claude Flow swarms, detects bottlenecks, and emits optimization recommendations.
Install
npx skills add https://github.com/ruvnet/ruflo --skill performance-analysisWhat is this skill?
- Detects bottlenecks across communication, processing, memory, and network with optional auto-fix and threshold flags
- Runs via `npx claude-flow bottleneck detect` and `analysis performance-report` with swarm-id and time-range filters
- Generates performance reports in multiple formats with included metrics
- Provides AI-powered optimization recommendations from profiling data
- Consolidates profiling, reporting, and remediation guidance in one skill suite
- 4 bottleneck dimensions: communication, processing, memory, and network
Adoption & trust: 642 installs on skills.sh; 58.5k GitHub stars; 3/3 security scanners passed (skills.sh audits).
What problem does it solve?
You are running Claude Flow swarms but cannot tell whether slowdowns come from agent communication, CPU-bound steps, memory pressure, or network I/O.
Who is it for?
Indie builders operating Claude Flow swarms who want CLI-driven profiling before scaling agents or refactoring orchestration.
Skip if: Teams not using Claude Flow or `npx claude-flow`, or anyone who only needs generic app APM without swarm-specific commands.
When should I use this skill?
Claude Flow swarms show unexplained slowness, you need a formal performance report, or you want optimization guidance after profiling.
What do I get? / Deliverables
You get a structured bottleneck profile, optional HTML performance report with metrics, and concrete optimization steps you can apply or auto-fix against a threshold.
- Bottleneck detection output
- Performance report (e.g. HTML with metrics)
- Optimization recommendations
Recommended Skills
Journey fit
Spans multiple journey phases - primary shelf plus alternate fits below.
Running multi-agent swarms in production needs measurable ops feedback; this skill is shelved under Operate because its core job is ongoing performance visibility and tuning. Bottleneck detection, profiling, and HTML/metrics reports map directly to monitoring and observability, not one-off launch or ideation work.
Where it fits
Generate an HTML performance report with metrics before tagging a swarm release.
Run bottleneck detect on the current swarm after users report intermittent agent timeouts.
Apply threshold-based detect --fix and compare recommendations after changing task routing.
Profile a new swarm topology locally before promoting it to a shared environment.
How it compares
Use instead of generic log scanning when you need swarm-oriented bottleneck taxonomy and bundled report generation.
Common Questions / FAQ
Who is performance-analysis for?
Solo and indie builders who deploy Claude Flow swarms and need monitoring-style performance analysis tied to swarm IDs, thresholds, and Claude Flow CLI workflows.
When should I use performance-analysis?
Use it in Operate when monitoring production or staging swarms, in Ship when validating perf before release, and after changing agent topology or communication patterns to re-baseline latency and memory.
Is performance-analysis safe to install?
Review the Security Audits panel on this Prism page and treat auto-fix and shell-backed CLI invocations as privileged; only run against swarms and environments you control.
SKILL.md
READMESKILL.md - Performance Analysis
# Performance Analysis Skill Comprehensive performance analysis suite for identifying bottlenecks, profiling swarm operations, generating detailed reports, and providing actionable optimization recommendations. ## Overview This skill consolidates all performance analysis capabilities: - **Bottleneck Detection**: Identify performance bottlenecks across communication, processing, memory, and network - **Performance Profiling**: Real-time monitoring and historical analysis of swarm operations - **Report Generation**: Create comprehensive performance reports in multiple formats - **Optimization Recommendations**: AI-powered suggestions for improving performance ## Quick Start ### Basic Bottleneck Detection ```bash npx claude-flow bottleneck detect ``` ### Generate Performance Report ```bash npx claude-flow analysis performance-report --format html --include-metrics ``` ### Analyze and Auto-Fix ```bash npx claude-flow bottleneck detect --fix --threshold 15 ``` ## Core Capabilities ### 1. Bottleneck Detection #### Command Syntax ```bash npx claude-flow bottleneck detect [options] ``` #### Options - `--swarm-id, -s <id>` - Analyze specific swarm (default: current) - `--time-range, -t <range>` - Analysis period: 1h, 24h, 7d, all (default: 1h) - `--threshold <percent>` - Bottleneck threshold percentage (default: 20) - `--export, -e <file>` - Export analysis to file - `--fix` - Apply automatic optimizations #### Usage Examples ```bash # Basic detection for current swarm npx claude-flow bottleneck detect # Analyze specific swarm over 24 hours npx claude-flow bottleneck detect --swarm-id swarm-123 -t 24h # Export detailed analysis npx claude-flow bottleneck detect -t 24h -e bottlenecks.json # Auto-fix detected issues npx claude-flow bottleneck detect --fix --threshold 15 # Low threshold for sensitive detection npx claude-flow bottleneck detect --threshold 10 --export critical-issues.json ``` #### Metrics Analyzed **Communication Bottlenecks:** - Message queue delays - Agent response times - Coordination overhead - Memory access patterns - Inter-agent communication latency **Processing Bottlenecks:** - Task completion times - Agent utilization rates - Parallel execution efficiency - Resource contention - CPU$memory usage patterns **Memory Bottlenecks:** - Cache hit rates - Memory access patterns - Storage I/O performance - Neural pattern loading times - Memory allocation efficiency **Network Bottlenecks:** - API call latency - MCP communication delays - External service timeouts - Concurrent request limits - Network throughput issues #### Output Format ``` 🔍 Bottleneck Analysis Report ━━━━━━━━━━━━━━━━━━━━━━━━━━━ 📊 Summary ├── Time Range: Last 1 hour ├── Agents Analyzed: 6 ├── Tasks Processed: 42 └── Critical Issues: 2 🚨 Critical Bottlenecks 1. Agent Communication (35% impact) └── coordinator → coder-1 messages delayed by 2.3s avg 2. Memory Access (28% impact) └── Neural pattern loading taking 1.8s per access ⚠️ Warning Bottlenecks 1. Task Queue (18% impact) └── 5 tasks waiting > 10s for assignment 💡 Recommendations 1. Switch to hierarchical topology (est. 40% improvement) 2. Enable memory caching (est. 25% improvement) 3. Increase agent concurrency to 8 (est. 20% improvement) ✅ Quick Fixes Available Run with --fix to apply: - Enable smart caching - Optimize message routing - Adjust agent priorities ``` ### 2. Performance Profiling #### Real-time Detection Automatic analysis during task execution: - Execution time vs. complexity - Agent utilization rates - Resource constraints - Operation patterns #### Common Bottleneck Patterns **Time Bottlenecks:** - Tasks taking > 5 minutes - Sequential operations t