Topology Optimizer Skill

Overview

This skill provides sophisticated swarm topology optimization capabilities including dynamic reconfiguration, network latency optimization, agent placement strategies, and communication pattern optimization for optimal swarm coordination.

When to Use

• Optimizing swarm communication patterns

• Reducing network latency and overhead

• Dynamic topology reconfiguration based on workload

• Agent placement for minimal communication distance

• Scaling swarms while maintaining performance

• AI-powered topology prediction and optimization

Quick Start

Analyze current topology

npx claude-flow topology-analyze --swarm-id <id> --metrics performance

Optimize topology automatically

npx claude-flow topology-optimize --swarm-id <id> --strategy adaptive

Compare topology configurations

npx claude-flow topology-compare --topologies ["hierarchical", "mesh", "hybrid"]

Generate topology recommendations

npx claude-flow topology-recommend --workload-profile <file> --constraints <file>

Architecture

+-----------------------------------------------------------+ | Topology Optimizer | +-----------------------------------------------------------+ | Topology Engine | Network Optimizer | Placement Algo | +-------------------+---------------------+-----------------+ | | | v v v +----------------+ +------------------+ +------------------+ | Topologies | | Latency Optimize | | Placement Algos | | - Hierarchical | | - Physical | | - Genetic | | - Mesh | | - Routing | | - Sim Annealing | | - Ring | | - Protocol | | - Particle Swarm | | - Star | | - Caching | | - Graph Partition| | - Hybrid | | - Compression | | - ML-Based | +----------------+ +------------------+ +------------------+ | | | v v v +-----------------------------------------------------------+ | Communication Pattern Optimizer | +-----------------------------------------------------------+

Topology Types

Topology Best For Latency Scalability Fault Tolerance

Hierarchical Large teams, clear hierarchy Medium High Medium

Mesh Small teams, high collaboration Low Low High

Ring Sequential processing Medium Medium Low

Star Central coordination Low Medium Low

Hybrid Complex workloads Variable High High

Adaptive Dynamic workloads Optimized High High

Core Capabilities

1. Dynamic Topology Reconfiguration

// Topology optimization workflow const optimization = await topologyOptimizer.optimize(swarm, workloadProfile, { minImprovement: 0.1, // Only change if 10%+ improvement migrationCost: 0.05, // Factor in migration overhead constraints: { maxAgentsPerNode: 10, minConnectivity: 2, maxLatency: 100 // ms } });

// Returns: // - recommended: Optimal topology // - improvement: Expected improvement % // - migrationPlan: Steps to migrate // - benefits: Detailed improvements

2. Network Latency Optimization

Multi-layer optimization:

Layer Optimization Impact

Physical Agent placement, bandwidth 20-40%

Routing Path optimization, load balancing 10-30%

Protocol TCP/UDP/gRPC selection 5-15%

Caching Reduce redundant communication 30-50%

Compression Reduce payload size 10-25%

3. Agent Placement Algorithms

Multi-algorithm optimization:

// Agent placement strategies const placementAlgorithms = { genetic: { populationSize: 100, mutationRate: 0.1, maxGenerations: 500 }, simulated_annealing: { initialTemperature: 1000, coolingRate: 0.95, minTemperature: 1 }, particle_swarm: { swarmSize: 50, inertia: 0.7, cognitive: 1.5, social: 1.5 }, graph_partitioning: { objective: 'minimize_cut', balanceConstraint: 0.05 } };

4. Communication Pattern Optimization

// Message batching strategies const batchingStrategies = [ { type: 'time', interval: 100, minBatch: 5 }, { type: 'size', maxSize: 1024, timeout: 50 }, { type: 'adaptive', targetLatency: 20 }, { type: 'priority', highPriorityImmediate: true } ];

// Protocol selection per agent pair const protocolSelection = { tcp: { reliability: 0.99, latency: 'medium' }, udp: { reliability: 0.95, latency: 'low' }, websocket: { reliability: 0.98, latency: 'medium' }, grpc: { reliability: 0.99, latency: 'low' }, mqtt: { reliability: 0.97, latency: 'low' } };

Optimization Algorithms

Genetic Algorithm

// Evolve optimal topology const result = await geneticOptimizer.evolve( initialTopologies, fitnessFunction, { populationSize: 50, mutationRate: 0.1, crossoverRate: 0.8, maxGenerations: 100, eliteSize: 5 } );

// Operations: // - Selection: Tournament selection // - Crossover: Topology structure combination // - Mutation: Connection add/remove/modify

Simulated Annealing

// Find optimal through local search const result = await annealingOptimizer.optimize( initialTopology, objectiveFunction, { initialTemperature: 1000, coolingRate: 0.95, minTemperature: 1, maxIterations: 10000 } );

// Neighbor generation: // - Add connection // - Remove connection // - Modify connection weight // - Relocate agent

MCP Integration

// Topology management integration const topologyIntegration = { // Real-time topology optimization async optimizeSwarmTopology(swarmId, config = {}) { const [status, performance, bottlenecks] = await Promise.all([ mcp.swarm_status({ swarmId }), mcp.performance_report({ format: 'detailed' }), mcp.bottleneck_analyze({ component: 'topology' }) ]);

const recommendations = this.generateRecommendations(
  status, performance, bottlenecks, config
);

if (recommendations.beneficial) {
  const result = await mcp.topology_optimize({ swarmId });
  return { applied: true, recommendations, result };
}

return { applied: false, recommendations };

},

// Scale with topology optimization async scaleWithTopology(swarmId, targetSize, workloadProfile) { await mcp.swarm_scale({ swarmId, targetSize }); await mcp.topology_optimize({ swarmId }); } };

Neural Network Integration

// AI-powered topology prediction const neuralOptimizer = { async predictOptimalTopology(swarmState, workloadProfile) { const model = await mcp.model_load({ modelPath: '/models/topology_optimizer.model' });

const features = this.extractFeatures(swarmState, workloadProfile);

const prediction = await mcp.neural_predict({
  modelId: model.id,
  input: JSON.stringify(features)
});

return {
  predictedTopology: prediction.topology,
  confidence: prediction.confidence,
  expectedImprovement: prediction.improvement
};

} };

Commands Reference

Analyze current topology

npx claude-flow topology-analyze --swarm-id <id> --metrics performance

Optimize topology automatically

npx claude-flow topology-optimize --swarm-id <id> --strategy adaptive

Compare topology configurations

npx claude-flow topology-compare --topologies ["hierarchical", "mesh", "hybrid"]

Generate topology recommendations

npx claude-flow topology-recommend --workload-profile <file>

Monitor topology performance

npx claude-flow topology-monitor --swarm-id <id> --interval 60

Optimize agent placement

npx claude-flow placement-optimize --algorithm genetic --agents <list>

Analyze placement efficiency

npx claude-flow placement-analyze --current-placement <config>

Key Metrics

Topology Performance Indicators

Category Metric Description

Communication Latency Average message latency

Communication Throughput Messages per second

Communication Bandwidth Util Network usage

Network Diameter Max hops between nodes

Network Clustering Coeff Local connectivity

Network Betweenness Critical path nodes

Fault Tolerance Connectivity Min cuts to disconnect

Fault Tolerance Redundancy Backup paths

Scalability Growth Capacity Max agents supported

Scalability Efficiency Performance at scale

Benchmark Results

const topologyBenchmarks = { hierarchical: { latency: 45, throughput: 1200, scalability: 0.95 }, mesh: { latency: 25, throughput: 2500, scalability: 0.70 }, ring: { latency: 80, throughput: 800, scalability: 0.85 }, star: { latency: 30, throughput: 1500, scalability: 0.75 }, hybrid: { latency: 35, throughput: 2000, scalability: 0.90 } };

Integration Points

Integration Purpose

Load Balancer Coordinate topology with load distribution

Performance Monitor Topology performance metrics

Resource Allocator Resource constraints for topology

Task Orchestrator Task distribution patterns

Best Practices

• Workload Analysis: Understand communication patterns before optimization

• Gradual Migration: Migrate topology incrementally

• Monitoring: Continuously monitor topology metrics

• Hybrid Approach: Combine topologies for different workload types

• AI-Assisted: Use ML models for complex optimization

• Cost-Benefit: Consider migration cost vs. performance gain

Example: Workload-Aware Topology

// Select topology based on workload const topologySelector = { selectTopology(workloadProfile) { const { coordination, parallelism, locality, faultTolerance } = workloadProfile;

if (coordination > 0.8 && locality > 0.7) {
  return 'hierarchical';  // High coordination, local processing
} else if (parallelism > 0.8 && faultTolerance > 0.7) {
  return 'mesh';          // High parallelism, fault tolerant
} else if (locality > 0.9) {
  return 'ring';          // Sequential, local processing
} else if (coordination > 0.9) {
  return 'star';          // Central coordination
}

return 'hybrid';          // Mixed workload

},

async optimizeForWorkload(swarmId, workloadProfile) { const recommended = this.selectTopology(workloadProfile); const current = await this.getCurrentTopology(swarmId);

if (recommended !== current) {
  await this.migrateTopology(swarmId, recommended);
}

} };

Related Skills

• optimization-monitor

• Real-time performance monitoring

• optimization-load-balancer

• Load distribution optimization

• optimization-resources

• Resource allocation

• optimization-benchmark

• Topology performance testing

Version History

• 1.0.0 (2026-01-02): Initial release - converted from topology-optimizer agent with dynamic reconfiguration, latency optimization, agent placement algorithms, genetic/simulated annealing optimization, and neural network integration