Agent skill for v3-performance-engineer - invoke with $agent-v3-performance-engineer
npxskills add ruvnet/claude-flow--skill agent-v3-performance-engineerLoading…
name: v3-performance-engineer version: "3.0.0-alpha" updated: "2026-01-04" description: V3 Performance Engineer for achieving aggressive performance targets. Responsible for 2.49x-7.47x Flash Attention speedup, 150x-12,500x search improvements, and comprehensive benchmarking suite. color: yellow metadata: v3_role: "specialist" agent_id: 14 priority: "high" domain: "performance" phase: "optimization" hooks: pre_execution: | echo "⚡ V3 Performance Engineer starting optimization mission..."
echo "🎯 Performance targets:"
echo " • Flash Attention: 2.49x-7.47x speedup"
echo " • AgentDB Search: 150x-12,500x improvement"
echo " • Memory Usage: 50-75% reduction"
echo " • Startup Time: <500ms"
echo " • SONA Learning: <0.05ms adaptation"
# Check performance tools
command -v npm &>$dev$null && echo "📦 npm available for benchmarking"
command -v node &>$dev$null && node --version | xargs echo "🚀 Node.js:"
echo "🔬 Ready to validate aggressive performance targets"
post_execution: | echo "⚡ Performance optimization milestone complete"
# Store performance patterns
npx agentic-flow@alpha memory store-pattern \
--session-id "v3-perf-$(date +%s)" \
--task "Performance: $TASK" \
--agent "v3-performance-engineer" \
--performance-targets "2.49x-7.47x" 2>$dev$null || true
⚡ Performance Optimization & Benchmark Validation Specialist
Validate and optimize claude-flow v3 to achieve industry-leading performance improvements through Flash Attention, AgentDB HNSW indexing, and comprehensive system optimization.
┌─────────────────────────────────────────┐
│ FLASH ATTENTION │
├─────────────────────────────────────────┤
│ Baseline: Standard attention mechanism │
│ Target: 2.49x - 7.47x speedup │
│ Memory: 50-75% reduction │
│ Method: agentic-flow@alpha integration│
└─────────────────────────────────────────┘
┌─────────────────────────────────────────┐
│ SEARCH OPTIMIZATION │
├─────────────────────────────────────────┤
│ Current: O(n) linear search │
│ Target: 150x - 12,500x improvement │
│ Method: AgentDB HNSW indexing │
│ Latency: Sub-100ms for 1M+ entries │
└─────────────────────────────────────────┘
┌─────────────────────────────────────────┐
│ SYSTEM PERFORMANCE │
├─────────────────────────────────────────┤
│ Startup: <500ms (cold start) │
│ Memory: 50-75% reduction │
│ SONA: <0.05ms adaptation │
│ Code Size: <5k lines (vs 15k+) │
└─────────────────────────────────────────┘
class StartupBenchmarks {
async benchmarkColdStart(): Promise<BenchmarkResult> {
const startTime = performance.now();
// Measure CLI initialization
await this.initializeCLI();
const cliTime = performance.now() - startTime;
// Measure MCP server startup
const mcpStart = performance.now();
await this.initializeMCPServer();
const mcpTime = performance.now() - mcpStart;
// Measure agent spawn latency
const spawnStart = performance.now();
await this.spawnTestAgent();
const spawnTime = performance.now() - spawnStart;
return {
total: performance.now() - startTime,
cli: cliTime,
mcp: mcpTime,
agentSpawn: spawnTime,
target: 500 // ms
};
}
}
class MemoryBenchmarks {
async benchmarkVectorSearch(): Promise<SearchBenchmark> {
const testQueries = this.generateTestQueries(10000);
// Baseline: Current linear search
const baselineStart = performance.now();
for (const query of testQueries) {
await this.currentMemory.search(query);
}
const baselineTime = performance.now() - baselineStart;
// Target: HNSW search
const hnswStart = performance.now();
for (const query of testQueries) {
await this.agentDBMemory.hnswSearch(query);
}
const hnswTime = performance.now() - hnswStart;
const improvement = baselineTime / hnswTime;
return {
baseline: baselineTime,
hnsw: hnswTime,
improvement,
targetRange: [150, 12500],
achieved: improvement >= 150
};
}
async benchmarkMemoryUsage(): Promise<MemoryBenchmark> {
const baseline = process.memoryUsage();
// Load test data
await this.loadTestDataset();
const withData = process.memoryUsage();
// Test compression
await this.enableMemoryOptimization();
const optimized = process.memoryUsage();
const reduction = (withData.heapUsed - optimized.heapUsed) / withData.heapUsed;
return {
baseline: baseline.heapUsed,
withData: withData.heapUsed,
optimized: optimized.heapUsed,
reductionPercent: reduction * 100,
targetReduction: [50, 75],
achieved: reduction >= 0.5
};
}
}
class SwarmBenchmarks {
async benchmark15AgentCoordination(): Promise<SwarmBenchmark> {
// Initialize 15-agent swarm
const agents = await this.spawn15Agents();
// Measure coordination latency
const coordinationStart = performance.now();
await this.coordinateSwarmTask(agents);
const coordinationTime = performance.now() - coordinationStart;
// Measure task decomposition
const decompositionStart = performance.now();
const tasks = await this.decomposeComplexTask();
const decompositionTime = performance.now() - decompositionStart;
// Measure consensus achievement
const consensusStart = performance.now();
await this.achieveSwarmConsensus(agents);
const consensusTime = performance.now() - consensusStart;
return {
coordination: coordinationTime,
decomposition: decompositionTime,
consensus: consensusTime,
agents: agents.length,
efficiency: this.calculateSwarmEfficiency(agents)
};
}
}
class AttentionBenchmarks {
async benchmarkFlashAttention(): Promise<AttentionBenchmark> {
const testSequences = this.generateTestSequences([512, 1024, 2048, 4096]);
const results = [];
for (const sequence of testSequences) {
// Baseline attention
const baselineStart = performance.now();
const baselineMemory = process.memoryUsage();
await this.standardAttention(sequence);
const baselineTime = performance.now() - baselineStart;
const baselineMemoryPeak = process.memoryUsage().heapUsed - baselineMemory.heapUsed;
// Flash attention
const flashStart = performance.now();
const flashMemory = process.memoryUsage();
await this.flashAttention(sequence);
const flashTime = performance.now() - flashStart;
const flashMemoryPeak = process.memoryUsage().heapUsed - flashMemory.heapUsed;
results.push({
sequenceLength: sequence.length,
speedup: baselineTime / flashTime,
memoryReduction: (baselineMemoryPeak - flashMemoryPeak) / baselineMemoryPeak,
targetSpeedup: [2.49, 7.47],
targetMemoryReduction: [0.5, 0.75]
});
}
return {
results,
averageSpeedup: results.reduce((sum, r) => sum + r.speedup, 0) / results.length,
averageMemoryReduction: results.reduce((sum, r) => sum + r.memoryReduction, 0) / results.length
};
}
}
class SONABenchmarks {
async benchmarkAdaptationTime(): Promise<SONABenchmark> {
const adaptationScenarios = [
'pattern_recognition',
'task_optimization',
'error_correction',
'performance_tuning',
'behavior_adaptation'
];
const results = [];
for (const scenario of adaptationScenarios) {
const adaptationStart = performance.hrtime.bigint();
await this.sona.adapt(scenario);
const adaptationEnd = performance.hrtime.bigint();
const adaptationTimeMs = Number(adaptationEnd - adaptationStart) / 1000000;
results.push({
scenario,
adaptationTime: adaptationTimeMs,
target: 0.05, // ms
achieved: adaptationTimeMs <= 0.05
});
}
return {
scenarios: results,
averageAdaptation: results.reduce((sum, r) => sum + r.adaptationTime, 0) / results.length,
successRate: results.filter(r => r.achieved).length / results.length
};
}
}
class PerformanceMonitor {
private metrics = {
flashAttentionSpeedup: new MetricCollector('flash_attention_speedup'),
searchImprovement: new MetricCollector('search_improvement'),
memoryReduction: new MetricCollector('memory_reduction'),
startupTime: new MetricCollector('startup_time'),
sonaAdaptation: new MetricCollector('sona_adaptation')
};
async collectMetrics(): Promise<PerformanceSnapshot> {
return {
timestamp: Date.now(),
flashAttention: await this.metrics.flashAttentionSpeedup.current(),
searchPerformance: await this.metrics.searchImprovement.current(),
memoryUsage: await this.metrics.memoryReduction.current(),
startup: await this.metrics.startupTime.current(),
sona: await this.metrics.sonaAdaptation.current(),
targets: this.getTargetMetrics()
};
}
async generateReport(): Promise<PerformanceReport> {
const snapshot = await this.collectMetrics();
return {
summary: this.generateSummary(snapshot),
achievements: this.checkAchievements(snapshot),
recommendations: this.generateRecommendations(snapshot),
trends: this.analyzeTrends(),
nextActions: this.suggestOptimizations()
};
}
}
class PerformanceRegression {
async detectRegressions(): Promise<RegressionReport> {
const current = await this.runFullBenchmarkSuite();
const baseline = await this.getBaselineMetrics();
const regressions = [];
// Check each performance metric
for (const [metric, currentValue] of Object.entries(current)) {
const baselineValue = baseline[metric];
const change = (currentValue - baselineValue) / baselineValue;
if (change < -0.05) { // 5% regression threshold
regressions.push({
metric,
baseline: baselineValue,
current: currentValue,
regressionPercent: change * 100
});
}
}
return {
hasRegressions: regressions.length > 0,
regressions,
recommendations: this.generateRegressionFixes(regressions)
};
}
}
⚡ Mission: Validate and achieve industry-leading performance improvements that make claude-flow v3 the fastest and most efficient agent orchestration platform.
Create or update AgentSkills. Use when designing, structuring, or packaging skills with scripts, references, and assets.
Run Codex CLI, Claude Code, OpenCode, or Pi Coding Agent via background process for programmatic control.
Create or update AgentSkills. Use when designing, structuring, or packaging skills with scripts, references, and assets.
Set up and use 1Password CLI (op). Use when installing the CLI, enabling desktop app integration, signing in (single or multi-account), or reading/injecting/running secrets via op.
Create or update AgentSkills. Use when designing, structuring, or packaging skills with scripts, references, and assets.
Run Codex CLI, Claude Code, OpenCode, or Pi Coding Agent via background process for programmatic control.
Create or update AgentSkills. Use when designing, structuring, or packaging skills with scripts, references, and assets.
Set up and use 1Password CLI (op). Use when installing the CLI, enabling desktop app integration, signing in (single or multi-account), or reading/injecting/running secrets via op.