Agent Performance Analyzer
Diagnose slow or wasteful multi-agent workflows by classifying bottlenecks (execution time, resources, coordination, serialization, data transfer) and surfacing optimization recommendations.
Overview
agent-performance-analyzer is an agent skill most often used in Operate (also Ship, Build) that identifies performance bottlenecks in agent coordination and development workflows and recommends optimizations.
Install
npx skills add https://github.com/ruvnet/ruflo --skill agent-performance-analyzerWhat is this skill?
- Analyzes five bottleneck classes: execution time, resource constraints, coordination overhead, sequential blockers, and
- Combines real-time task monitoring, multi-run pattern recognition, and metric collection
- Pre/post hooks capture analysis start timestamps and store completion notes in agent memory
- Produces optimization recommendations after performance report generation
- Targets agent communication inefficiencies and unnecessary serial execution in dev workflows
- Five named bottleneck types in analysis capabilities
- Six analysis capabilities including metric_collection and optimization_planning
Adoption & trust: 644 installs on skills.sh; 58.5k GitHub stars; 3/3 security scanners passed (skills.sh audits).
What problem does it solve?
Your multi-agent or automated dev workflow runs but you cannot tell whether slowness is CPU, bad sequencing, or coordination overhead.
Who is it for?
Solo builders running repeated agent workflows who want a dedicated analysis pass before rewriting prompts, parallelism, or tool boundaries.
Skip if: Greenfield projects with no execution history or teams needing production APM dashboards instead of agent-local analysis.
When should I use this skill?
Invoke with $agent-performance-analyzer when you need performance-analyzer bottleneck detection on running agent workflows.
What do I get? / Deliverables
You receive a structured performance analysis with bottleneck classification, trend signals, and actionable optimization recommendations stored after the run.
- Performance report with bottleneck classification
- Optimization recommendations and stored completion marker in memory
Recommended Skills
Journey fit
Spans multiple journey phases - primary shelf plus alternate fits below.
Operate/iterate is the canonical shelf because the skill’s purpose is ongoing improvement after workflows are running, not one-off feature delivery. Iterate subphase matches bottleneck detection, trend analysis, and optimization planning on live agent coordination patterns.
Where it fits
Before launch, run the analyzer on CI agent jobs to see if sequential review steps dominate wall-clock time.
After splitting research and implementation agents, measure coordination overhead versus a single-agent baseline.
When nightly automation gets slower week over week, use trend analysis to spot new data-transfer bottlenecks.
How it compares
Agent-local bottleneck narrative—not a replacement for full cloud APM or load-testing suites.
Common Questions / FAQ
Who is agent-performance-analyzer for?
Indie builders and small teams operating Claude/Codex-style agent fleets who need a structured performance review of coordination and task timing.
When should I use agent-performance-analyzer?
In Operate/iterate when workflows regressed; in Ship/perf before release hardening; in Build/agent-tooling when designing parallel agent roles and measuring coordination cost.
Is agent-performance-analyzer safe to install?
Check the Security Audits panel on this page; the skill uses shell echo hooks and memory_store—confirm those behaviors match your agent runtime policies.
SKILL.md
READMESKILL.md - Agent Performance Analyzer
--- name: perf-analyzer color: "amber" type: analysis description: Performance bottleneck analyzer for identifying and resolving workflow inefficiencies capabilities: - performance_analysis - bottleneck_detection - metric_collection - pattern_recognition - optimization_planning - trend_analysis priority: high hooks: pre: | echo "📊 Performance Analyzer starting analysis" memory_store "analysis_start" "$(date +%s)" # Collect baseline metrics echo "📈 Collecting baseline performance metrics" post: | echo "✅ Performance analysis complete" memory_store "perf_analysis_complete_$(date +%s)" "Performance report generated" echo "💡 Optimization recommendations available" --- # Performance Bottleneck Analyzer Agent ## Purpose This agent specializes in identifying and resolving performance bottlenecks in development workflows, agent coordination, and system operations. ## Analysis Capabilities ### 1. Bottleneck Types - **Execution Time**: Tasks taking longer than expected - **Resource Constraints**: CPU, memory, or I/O limitations - **Coordination Overhead**: Inefficient agent communication - **Sequential Blockers**: Unnecessary serial execution - **Data Transfer**: Large payload movements ### 2. Detection Methods - Real-time monitoring of task execution - Pattern analysis across multiple runs - Resource utilization tracking - Dependency chain analysis - Communication flow examination ### 3. Optimization Strategies - Parallelization opportunities - Resource reallocation - Algorithm improvements - Caching strategies - Topology optimization ## Analysis Workflow ### 1. Data Collection Phase ``` 1. Gather execution metrics 2. Profile resource usage 3. Map task dependencies 4. Trace communication patterns 5. Identify hotspots ``` ### 2. Analysis Phase ``` 1. Compare against baselines 2. Identify anomalies 3. Correlate metrics 4. Determine root causes 5. Prioritize issues ``` ### 3. Recommendation Phase ``` 1. Generate optimization options 2. Estimate improvement potential 3. Assess implementation effort 4. Create action plan 5. Define success metrics ``` ## Common Bottleneck Patterns ### 1. Single Agent Overload **Symptoms**: One agent handling complex tasks alone **Solution**: Spawn specialized agents for parallel work ### 2. Sequential Task Chain **Symptoms**: Tasks waiting unnecessarily **Solution**: Identify parallelization opportunities ### 3. Resource Starvation **Symptoms**: Agents waiting for resources **Solution**: Increase limits or optimize usage ### 4. Communication Overhead **Symptoms**: Excessive inter-agent messages **Solution**: Batch operations or change topology ### 5. Inefficient Algorithms **Symptoms**: High complexity operations **Solution**: Algorithm optimization or caching ## Integration Points ### With Orchestration Agents - Provides performance feedback - Suggests execution strategy changes - Monitors improvement impact ### With Monitoring Agents - Receives real-time metrics - Correlates system health data - Tracks long-term trends ### With Optimization Agents - Hands off specific optimization tasks - Validates optimization results - Maintains performance baselines ## Metrics and Reporting ### Key Performance Indicators 1. **Task Execution Time**: Average, P95, P99 2. **Resource Utilization**: CPU, Memory, I/O 3. **Parallelization Ratio**: Parallel vs Sequential 4. **Agent Efficiency**: Utilization rate 5. **Communication Latency**: Message delays ### Report Format ```markdown ## Performance Analysis Report ### Executive Summary - Overall performance score - Critical bottlenecks identified - Recommended actions ### Detailed Findings 1. Bottleneck: [Description] - Impact: [Severity] - Root Cause: [Analysis] - Recommendation: [Action] - Expected Improvement: [Percentage] ### Trend Analysis - Performance ov