Output format·Analytics & Monitoring·v1.0.0

Performance Analysis

Name: Performance Analysis
Author: ruvnet

Comprehensive performance analysis, bottleneck detection, and optimization recommendations for Claude Flow swarms.

You say

Buy it · $29 Read it before you buy $29 Written by ruvnet · unverified publisher

Context cost: 3.7k tokensestimated from the bundle, loaded when it triggers
Bundle: 1 file · 14.7 kBtext throughout, nothing executable
Licence: MITpaid listing
Last change: —v1.0.0
Servers it uses: Noneruns standalone

What it does

Comprehensive performance analysis, bottleneck detection, and optimization recommendations for Claude Flow swarms

Installed, it changes the agent in these ways.

What this skill changes about the agent is not written down here yet. The listing was collected from its source, and the description is in its own SKILL.md.

Output format

Produces one artefact, exactly shaped.

performancebottleneckoptimizationprofilingmetricsanalysisanalytics

Filed under

Analytics & Monitoring

The skill itself

This is the whole product. A skill is instructions the model reads, so there is nothing behind the listing you cannot see first — the front matter loads with every session, and the body below it loads when the skill triggers.

SKILL.md14.7 kB · 564 lines

--- name: performance-analysis version: 1.0.0 description: Comprehensive performance analysis, bottleneck detection, and optimization recommendations for Claude Flow swarms category: monitoring tags: [performance, bottleneck, optimization, profiling, metrics, analysis] author: Claude Flow Team ---

10# Performance Analysis Skill

12Comprehensive performance analysis suite for identifying bottlenecks, profiling swarm operations, generating detailed reports, and providing actionable optimization recommendations.

14## Overview

16This skill consolidates all performance analysis capabilities:

17- **Bottleneck Detection**: Identify performance bottlenecks across communication, processing, memory, and network

18- **Performance Profiling**: Real-time monitoring and historical analysis of swarm operations

19- **Report Generation**: Create comprehensive performance reports in multiple formats

20- **Optimization Recommendations**: AI-powered suggestions for improving performance

22## Quick Start

24### Basic Bottleneck Detection

25```bash

26npx claude-flow bottleneck detect

27```

29### Generate Performance Report

30```bash

31npx claude-flow analysis performance-report --format html --include-metrics

32```

34### Analyze and Auto-Fix

35```bash

36npx claude-flow bottleneck detect --fix --threshold 15

37```

39## Core Capabilities

41### 1. Bottleneck Detection

43#### Command Syntax

44```bash

45npx claude-flow bottleneck detect [options]

46```

48#### Options

49- --swarm-id, -s <id> - Analyze specific swarm (default: current)

50- --time-range, -t <range> - Analysis period: 1h, 24h, 7d, all (default: 1h)

51- --threshold <percent> - Bottleneck threshold percentage (default: 20)

52- --export, -e <file> - Export analysis to file

53- --fix - Apply automatic optimizations

55#### Usage Examples

56```bash

57# Basic detection for current swarm

58npx claude-flow bottleneck detect

60# Analyze specific swarm over 24 hours

61npx claude-flow bottleneck detect --swarm-id swarm-123 -t 24h

63# Export detailed analysis

64npx claude-flow bottleneck detect -t 24h -e bottlenecks.json

66# Auto-fix detected issues

67npx claude-flow bottleneck detect --fix --threshold 15

69# Low threshold for sensitive detection

70npx claude-flow bottleneck detect --threshold 10 --export critical-issues.json

71```

73#### Metrics Analyzed

75**Communication Bottlenecks:**

76- Message queue delays

77- Agent response times

78- Coordination overhead

79- Memory access patterns

80- Inter-agent communication latency

82**Processing Bottlenecks:**

83- Task completion times

84- Agent utilization rates

85- Parallel execution efficiency

86- Resource contention

87- CPU/memory usage patterns

89**Memory Bottlenecks:**

90- Cache hit rates

91- Memory access patterns

92- Storage I/O performance

93- Neural pattern loading times

94- Memory allocation efficiency

96**Network Bottlenecks:**

97- API call latency

98- MCP communication delays

99- External service timeouts

100- Concurrent request limits

101- Network throughput issues

102

103#### Output Format

104```

105🔍 Bottleneck Analysis Report

106━━━━━━━━━━━━━━━━━━━━━━━━━━━

107

108📊 Summary

109├── Time Range: Last 1 hour

110├── Agents Analyzed: 6

111├── Tasks Processed: 42

112└── Critical Issues: 2

113

114🚨 Critical Bottlenecks

1151. Agent Communication (35% impact)

116 └── coordinator → coder-1 messages delayed by 2.3s avg

117

1182. Memory Access (28% impact)

119 └── Neural pattern loading taking 1.8s per access

120

121⚠️ Warning Bottlenecks

1221. Task Queue (18% impact)

123 └── 5 tasks waiting > 10s for assignment

124

125💡 Recommendations

1261. Switch to hierarchical topology (est. 40% improvement)

1272. Enable memory caching (est. 25% improvement)

1283. Increase agent concurrency to 8 (est. 20% improvement)

129

130✅ Quick Fixes Available

131Run with --fix to apply:

132- Enable smart caching

133- Optimize message routing

134- Adjust agent priorities

135```

136

137### 2. Performance Profiling

138

139#### Real-time Detection

140Automatic analysis during task execution:

141- Execution time vs. complexity

142- Agent utilization rates

143- Resource constraints

144- Operation patterns

145

146#### Common Bottleneck Patterns

147

148**Time Bottlenecks:**

149- Tasks taking > 5 minutes

150- Sequential operations that could parallelize

151- Redundant file operations

152- Inefficient algorithm implementations

153

154**Coordination Bottlenecks:**

155- Single agent for complex tasks

156- Unbalanced agent workloads

157- Poor topology selection

158- Excessive synchronization points

159

160**Resource Bottlenecks:**

161- High operation count (> 100)

162- Memory constraints

163- I/O limitations

164- Thread pool saturation

165

166#### MCP Integration

167```javascript

168// Check for bottlenecks in Claude Code

169mcp__claude-flow__bottleneck_detect({

170 timeRange: "1h",

171 threshold: 20,

172 autoFix: false

173})

174

175// Get detailed task results with bottleneck analysis

176mcp__claude-flow__task_results({

177 taskId: "task-123",

178 format: "detailed"

179})

180```

181

182**Result Format:**

183```json

184{

185 "bottlenecks": [

186 {

187 "type": "coordination",

188 "severity": "high",

189 "description": "Single agent used for complex task",

190 "recommendation": "Spawn specialized agents for parallel work",

191 "impact": "35%",

192 "affectedComponents": ["coordinator", "coder-1"]

193 }

194 ],

195 "improvements": [

196 {

197 "area": "execution_time",

198 "suggestion": "Use parallel task execution",

199 "expectedImprovement": "30-50% time reduction",

200 "implementationSteps": [

201 "Split task into smaller units",

202 "Spawn 3-4 specialized agents",

203 "Use mesh topology for coordination"

204 ]

205 }

206 ],

207 "metrics": {

208 "avgExecutionTime": "142s",

209 "agentUtilization": "67%",

210 "cacheHitRate": "82%",

211 "parallelizationFactor": 1.2

212 }

213}

214```

215

216### 3. Report Generation

217

218#### Command Syntax

219```bash

220npx claude-flow analysis performance-report [options]

221```

222

223#### Options

224- --format <type> - Report format: json, html, markdown (default: markdown)

225- --include-metrics - Include detailed metrics and charts

226- --compare <id> - Compare with previous swarm

227- --time-range <range> - Analysis period: 1h, 24h, 7d, 30d, all

228- --output <file> - Output file path

229- --sections <list> - Comma-separated sections to include

230

231#### Report Sections

2321. **Executive Summary**

233 - Overall performance score

234 - Key metrics overview

235 - Critical findings

236

2372. **Swarm Overview**

238 - Topology configuration

239 - Agent distribution

240 - Task statistics

241

2423. **Performance Metrics**

243 - Execution times

244 - Throughput analysis

245 - Resource utilization

246 - Latency breakdown

247

2484. **Bottleneck Analysis**

249 - Identified bottlenecks

250 - Impact assessment

251 - Optimization priorities

252

2535. **Comparative Analysis** (when --compare used)

254 - Performance trends

255 - Improvement metrics

256 - Regression detection

257

2586. **Recommendations**

259 - Prioritized action items

260 - Expected improvements

261 - Implementation guidance

262

263#### Usage Examples

264```bash

265# Generate HTML report with all metrics

266npx claude-flow analysis performance-report --format html --include-metrics

267

268# Compare current swarm with previous

269npx claude-flow analysis performance-report --compare swarm-123 --format markdown

270

271# Custom output with specific sections

272npx claude-flow analysis performance-report \

273 --sections summary,metrics,recommendations \

274 --output reports/perf-analysis.html \

275 --format html

276

277# Weekly performance report

278npx claude-flow analysis performance-report \

279 --time-range 7d \

280 --include-metrics \

281 --format markdown \

282 --output docs/weekly-performance.md

283

284# JSON format for CI/CD integration

285npx claude-flow analysis performance-report \

286 --format json \

287 --output build/performance.json

288```

289

290#### Sample Markdown Report

291```markdown

292# Performance Analysis Report

293

294## Executive Summary

295- **Overall Score**: 87/100

296- **Analysis Period**: Last 24 hours

297- **Swarms Analyzed**: 3

298- **Critical Issues**: 1

299

300## Key Metrics

302|--------|-------|-------|--------|

303| Avg Task Time | 42s | ↓ 12% | 35s |

304| Agent Utilization | 78% | ↑ 5% | 85% |

305| Cache Hit Rate | 91% | → | 90% |

306| Parallel Efficiency | 2.3x | ↑ 0.4x | 2.5x |

307

308## Bottleneck Analysis

309### Critical

3101. **Agent Communication Delay** (Impact: 35%)

311 - Coordinator → Coder messages delayed by 2.3s avg

312 - **Fix**: Switch to hierarchical topology

313

314### Warnings

3151. **Memory Access Pattern** (Impact: 18%)

316 - Neural pattern loading: 1.8s per access

317 - **Fix**: Enable memory caching

318

319## Recommendations

3201. **High Priority**: Switch to hierarchical topology (40% improvement)

3212. **Medium Priority**: Enable memory caching (25% improvement)

3223. **Low Priority**: Increase agent concurrency to 8 (20% improvement)

323```

324

325### 4. Optimization Recommendations

326

327#### Automatic Fixes

328When using --fix, the following optimizations may be applied:

329

330**1. Topology Optimization**

331- Switch to more efficient topology (mesh → hierarchical)

332- Adjust communication patterns

333- Reduce coordination overhead

334- Optimize message routing

335

336**2. Caching Enhancement**

337- Enable memory caching

338- Optimize cache strategies

339- Preload common patterns

340- Implement cache warming

341

342**3. Concurrency Tuning**

343- Adjust agent counts

344- Optimize parallel execution

345- Balance workload distribution

346- Implement load balancing

347

348**4. Priority Adjustment**

349- Reorder task queues

350- Prioritize critical paths

351- Reduce wait times

352- Implement fair scheduling

353

354**5. Resource Optimization**

355- Optimize memory usage

356- Reduce I/O operations

357- Batch API calls

358- Implement connection pooling

359

360#### Performance Impact

361Typical improvements after bottleneck resolution:

362

363- **Communication**: 30-50% faster message delivery

364- **Processing**: 20-40% reduced task completion time

365- **Memory**: 40-60% fewer cache misses

366- **Network**: 25-45% reduced API latency

367- **Overall**: 25-45% total performance improvement

368

369## Advanced Usage

370

371### Continuous Monitoring

372```bash

373# Monitor performance in real-time

374npx claude-flow swarm monitor --interval 5

375

376# Generate hourly reports

377while true; do

378 npx claude-flow analysis performance-report \

379 --format json \

380 --output logs/perf-$(date +%Y%m%d-%H%M).json

381 sleep 3600

382done

383```

384

385### CI/CD Integration

386```yaml

387# .github/workflows/performance.yml

388name: Performance Analysis

389on: [push, pull_request]

390

391jobs:

392 analyze:

393 runs-on: ubuntu-latest

394 steps:

395 - uses: actions/checkout@v2

396 - name: Run Performance Analysis

397 run: |

398 npx claude-flow analysis performance-report \

399 --format json \

400 --output performance.json

401 - name: Check Performance Thresholds

402 run: |

403 npx claude-flow bottleneck detect \

404 --threshold 15 \

405 --export bottlenecks.json

406 - name: Upload Reports

407 uses: actions/upload-artifact@v2

408 with:

409 name: performance-reports

410 path: |

411 performance.json

412 bottlenecks.json

413```

414

415### Custom Analysis Scripts

416```javascript

417// scripts/analyze-performance.js

418const { exec } = require('child_process');

419const fs = require('fs');

420

421async function analyzePerformance() {

422 // Run bottleneck detection

423 const bottlenecks = await runCommand(

424 'npx claude-flow bottleneck detect --format json'

425 );

426

427 // Generate performance report

428 const report = await runCommand(

429 'npx claude-flow analysis performance-report --format json'

430 );

431

432 // Analyze results

433 const analysis = {

434 bottlenecks: JSON.parse(bottlenecks),

435 performance: JSON.parse(report),

436 timestamp: new Date().toISOString()

437 };

438

439 // Save combined analysis

440 fs.writeFileSync(

441 'analysis/combined-report.json',

442 JSON.stringify(analysis, null, 2)

443 );

444

445 // Generate alerts if needed

446 if (analysis.bottlenecks.critical.length > 0) {

447 console.error('CRITICAL: Performance bottlenecks detected!');

448 process.exit(1);

449 }

450}

451

452function runCommand(cmd) {

453 return new Promise((resolve, reject) => {

454 exec(cmd, (error, stdout, stderr) => {

455 if (error) reject(error);

456 else resolve(stdout);

457 });

458 });

459}

460

461analyzePerformance().catch(console.error);

462```

463

464## Best Practices

465

466### 1. Regular Analysis

467- Run bottleneck detection after major changes

468- Generate weekly performance reports

469- Monitor trends over time

470- Set up automated alerts

471

472### 2. Threshold Tuning

473- Start with default threshold (20%)

474- Lower for production systems (10-15%)

475- Higher for development (25-30%)

476- Adjust based on requirements

477

478### 3. Fix Strategy

479- Always review before applying --fix

480- Test fixes in development first

481- Apply fixes incrementally

482- Monitor impact after changes

483

484### 4. Report Integration

485- Include in documentation

486- Share with team regularly

487- Track improvements over time

488- Use for capacity planning

489

490### 5. Continuous Optimization

491- Learn from each analysis

492- Build performance budgets

493- Establish baselines

494- Set improvement goals

495

496## Troubleshooting

497

498### Common Issues

499

500**High Memory Usage**

501```bash

502# Analyze memory bottlenecks

503npx claude-flow bottleneck detect --threshold 10

504

505# Check cache performance

506npx claude-flow cache manage --action stats

507

508# Review memory metrics

509npx claude-flow memory usage

510```

511

512**Slow Task Execution**

513```bash

514# Identify slow tasks

515npx claude-flow task status --detailed

516

517# Analyze coordination overhead

518npx claude-flow bottleneck detect --time-range 1h

519

520# Check agent utilization

521npx claude-flow agent metrics

522```

523

524**Poor Cache Performance**

525```bash

526# Analyze cache hit rates

527npx claude-flow analysis performance-report --sections metrics

528

529# Review cache strategy

530npx claude-flow cache manage --action analyze

531

532# Enable cache warming

533npx claude-flow bottleneck detect --fix

534```

535

536## Integration with Other Skills

537

538- **swarm-orchestration**: Use performance data to optimize topology

539- **memory-management**: Improve cache strategies based on analysis

540- **task-coordination**: Adjust scheduling based on bottlenecks

541- **neural-training**: Train patterns from performance data

542

543## Related Commands

544

545- npx claude-flow swarm monitor - Real-time monitoring

546- npx claude-flow token usage - Token optimization analysis

547- npx claude-flow cache manage - Cache optimization

548- npx claude-flow agent metrics - Agent performance metrics

549- npx claude-flow task status - Task execution analysis

550

551## See Also

552

553- [Bottleneck Detection Guide](/workspaces/claude-code-flow/.claude/commands/analysis/bottleneck-detect.md)

554- [Performance Report Guide](/workspaces/claude-code-flow/.claude/commands/analysis/performance-report.md)

555- [Performance Bottlenecks Overview](/workspaces/claude-code-flow/.claude/commands/analysis/performance-bottlenecks.md)

556- [Swarm Monitoring Documentation](../swarm-orchestration/SKILL.md)

557- [Memory Management Documentation](../memory-management/SKILL.md)

558

559---

560

561**Version**: 1.0.0

562**Last Updated**: 2025-10-19

563**Maintainer**: Claude Flow Team

564

In the file

SKILL.md1,820 words

Files1

LicenceMIT

Why you can read it

Nothing in a skill executes. The client loads the text and the model follows it, so a skill can be audited the way a runbook is — by reading it.

What it costs in context

Skills are not billed by the call. They are paid for in context: every token the instructions occupy is a token your code, your diff and your conversation cannot use. Here is what this one takes and when it takes it.

≈70

always loaded

The name and description, so the model knows the skill exists and when to reach for it.

3,605

on trigger

The instruction body, read only when the skill fires.

1.8%

of a 200k window

Ten skills this size would take about 18% of the window before you open a file.

050k100k150k200k context window

3.7k tokens, estimated from the bundle at four bytes to the token, held for the rest of the session once it triggers. Middling. Fine to keep on in a project where you use it weekly, worth unloading in one where you never do.

Servers bill, skills cost

A server charges by the month. A skill charges once per session, in context, and then keeps charging it for as long as the session lives.

Before and after

The same question, put to the same model twice: once as it comes, and once with these instructions loaded.

No worked example has been published for this skill yet.

Adoption

Installsnone yet

Ratingno reviews yet

The procedure it runs

The procedure has not been published here. It is in the skill’s own SKILL.md, which its author has not sent to the marketplace yet.

Prose, not code

These steps are written for a model to follow, not executed by a runtime. It can still be told to skip one, and it will say so when it does.

Servers it uses

None. This skill calls no MCP servers at all.

Everything it needs is in the instructions, so it works in a project with nothing connected — the model reads the file and changes how it works with what it can already reach.

It writes no files and reaches no network. All it changes is how the model reasons and writes.

What it asks for

Writes filesno

Network accessno

Read from the allowed-tools line of this skill’s own SKILL.md. A skill grants no permissions of its own — it can only ask for tools your client already has.

What it will not do

Every skill is narrow, and the useful ones say where they stop. These are the jobs this one is the wrong tool for.

What this skill is not for has not been published here. Nothing is implied by that: it is a section the author has not filled in.

If this is not it

21 other skills in Analytics & Monitoring

What is in the bundle

1 file, 14.7 kB on disk. A bundle is text throughout: the instructions the model reads, plus the templates it fills in.

SKILL.md14.7 kB

What is not in it

No dependencies and nothing executable: a skill is text the agent reads, so the bundle is 1 file you can review in full before installing. The MIT licence covers the templates and examples as well as the instructions.

Install

Installing copies the bundle into your project. Nothing runs at install time — the files sit on disk until the model reads them.

$29 once

Performance Analysis · MIT · ruvnet

one-time

Price$29 once

LicenceMIT — the author’s, unchanged by this purchase

Paid throughStripe, once, on the card you add at the checkout

Keeps workingfor good — the files are yours once they are on disk

Updatesevery release of 1.x through this account

You can read the whole bundle before paying — the SKILL.md above is the product, not a preview of it. What the money buys is the delivery: the folder packaged and handed to your machine by key, every update its author ships, and our support if it does not do what this listing says. The terms of use are MIT, set by the author and unchanged by buying it here.

Payment runs through Stripe, on a page like this one rather than a redirect. Once there is an account it joins the same mcprush invoice as everything else you run, so there is never a second card to enter.

Which clients pick it up on their own

A skill is a folder of text. A client with a skills folder reads it without being told; everywhere else the same text works, it is just handed to the model rather than found.

Claude Code.claude/skills/

Claude Desktop

ChatGPT

Cursor.cursor/skills/

VS Code.github/skills/

Codex CLI.agents/skills/

Gemini CLI.gemini/skills/

Grok.grok/skills/

Zed.agents/skills/

Windsurf.windsurf/skills/

Agent SDK.claude/skills/

HTTP / API

This release

Version1.0.0

Publishedno release date on file

Price$29

Referenceruvnet/performance-analysis

Versions

v1.0.0 is what is on the shelf; no release here carries a date. Instructions change more often than APIs do — a skill can be rewritten entirely without anything it depends on moving.

v1.0.0

No earlier releases have been published to the marketplace.

Pinning

Put ruvnet/performance-analysis@1.0.0 in the install command to hold this exact version. Without the suffix you get whatever is current the day you install, and nothing moves under you afterwards.

Reviews

—no reviews yet · no installs yet

Nobody has reviewed this skill yet. The rating is the mean of the reviews written here, so there is none until somebody writes the first.

Who can post

Only accounts that have had the skill installed for fourteen days, so a review is written after living with it rather than after reading it. Publishers may reply once.

Who wrote it

ruvnet

Publishes on mcprush.

0 servers listed20 skills listednot claimed

Profile

Publisher

Servers0