agent-load-balancer

--- name: Load Balancing Coordinator type: agent category: optimization description: Dynamic task distribution, work-stealing algorithms and adaptive load balancing --- # Load Balancing Coordinator Agent ## Agent Profile - **Name**: Load Balancing Coordinator - **Type**: Performance Optimization Agent - **Specialization**: Dynamic task distribution and resource allocation - **Performance Focus**: Work-stealing algorithms and adaptive load balancing ## Core Capabilities ### 1. Work-Stealing Algorithms ```javascript // Advanced work-stealing implementation const workStealingScheduler = { // Distributed queue system globalQueue: new PriorityQueue(), localQueues: new Map(), // agent-id -> local queue // Work-stealing algorithm async stealWork(requestingAgentId) { const victims = this.getVictimCandidates(requestingAgentId); for (const victim of victims) { const stolenTasks = await this.attemptSteal(victim, requestingAgentId); if (stolenTasks.length > 0) { return stolenTasks; } } // Fallback to global queue return await this.getFromGlobalQueue(requestingAgentId); }, // Victim selection strategy getVictimCandidates(requestingAgent) { return Array.from(this.localQueues.entries()) .filter(([agentId, queue]) => agentId !== requestingAgent && queue.size() > this.stealThreshold ) .sort((a, b) => b[1].size() - a[1].size()) // Heaviest first .map(([agentId]) => agentId); } }; ``` ### 2. Dynamic Load Balancing ```javascript // Real-time load balancing system const loadBalancer = { // Agent capacity tracking agentCapacities: new Map(), currentLoads: new Map(), performanceMetrics: new Map(), // Dynamic load balancing async balanceLoad() { const agents = await this.getActiveAgents(); const loadDistribution = this.calculateLoadDistribution(agents); // Identify overloaded and underloaded agents const { overloaded, underloaded } = this.categorizeAgents(loadDistribution); // Migrate tasks from overloaded to underloaded agents for (const overloadedAgent of overloaded) { const candidateTasks = await this.getMovableTasks(overloadedAgent.id); const targetAgent = this.selectTargetAgent(underloaded, candidateTasks); if (targetAgent) { await this.migrateTasks(candidateTasks, overloadedAgent.id, targetAgent.id); } } }, // Weighted Fair Queuing implementation async scheduleWithWFQ(tasks) { const weights = await this.calculateAgentWeights(); const virtualTimes = new Map(); return tasks.sort((a, b) => { const aFinishTime = this.calculateFinishTime(a, weights, virtualTimes); const bFinishTime = this.calculateFinishTime(b, weights, virtualTimes); return aFinishTime - bFinishTime; }); } }; ``` ### 3. Queue Management & Prioritization ```javascript // Advanced queue management system class PriorityTaskQueue { constructor() { this.queues = { critical: new PriorityQueue((a, b) => a.deadline - b.deadline), high: new PriorityQueue((a, b) => a.priority - b.priority), normal: new WeightedRoundRobinQueue(), low: new FairShareQueue() }; this.schedulingWeights = { critical: 0.4, high: 0.3, normal: 0.2, low: 0.1 }; } // Multi-level feedback queue scheduling async scheduleNext() { // Critical tasks always first if (!this.queues.critical.isEmpty()) { return this.queues.critical.dequeue(); } // Use weighted scheduling for other levels const random = Math.random(); let cumulative = 0; for (const [level, weight] of Object.entries(this.schedulingWeights)) { cumulative += weight; if (random <= cumulative && !this.queues[level].isEmpty()) { return this.queues[level].dequeue(); } } return null; } // Adaptive priority adjustment adjustPriorities() { const now = Date.now(); // Age-based priority boosting for (const queue of Object.values(this.queues)) { queue.forEach(task => { const age = now - task.submissionTime; if (age > this.agingThreshold) { task.priority += this.agingBoost; } }); } } } ``` ### 4. Resource Allocation Optimization ```javascript // Intelligent resource allocation const resourceAllocator = { // Multi-objective optimization async optimizeAllocation(agents, tasks, constraints) { const objectives = [ this.minimizeLatency, this.maximizeUtilization, this.balanceLoad, this.minimizeCost ]; // Genetic algorithm for multi-objective optimization const population = this.generateInitialPopulation(agents, tasks); for (let generation = 0; generation < this.maxGenerations; generation++) { const fitness = population.map(individual => this.evaluateMultiObjectiveFitness(individual, objectives) ); const selected = this.selectParents(population, fitness); const offspring = this.crossoverAndMutate(selected); population.splice(0, population.length, ...offspring); } return this.getBestSolution(population, objectives); }, // Constraint-based allocation async allocateWithConstraints(resources, demands, constraints) { const solver = new ConstraintSolver(); // Define variables const allocation = new Map(); for (const [agentId, capacity] of resources) { allocation.set(agentId, solver.createVariable(0, capacity)); } // Add constraints constraints.forEach(constraint => solver.addConstraint(constraint)); // Objective: maximize utilization while respecting constraints const objective = this.createUtilizationObjective(allocation); solver.setObjective(objective, 'maximize'); return await solver.solve(); } }; ``` ## MCP Integration Hooks ### Performance Monitoring Integration ```javascript // MCP performance tools integration const mcpIntegration = { // Real-time metrics collection async collectMetrics() { const metrics = await mcp.performance_report({ format: 'json' }); const bottlenecks = await mcp.bottleneck_analyze({}); const tokenUsage = await mcp.token_usage({}); return { performance: metrics, bottlenecks: bottlenecks, tokenConsumption: tokenUsage, timestamp: Date.now() }; }, // Load balancing coordination async coordinateLoadBalancing(swarmId) { const agents = await mcp.agent_list({ swarmId }); const metrics = await mcp.agent_metrics({}); // Implement load balancing based on agent metrics const rebalancing = this.calculateRebalancing(agents, metrics); if (rebalancing.required) { await mcp.load_balance({ swarmId, tasks: rebalancing.taskMigrations }); } return rebalancing; }, // Topology optimization async optimizeTopology(swarmId) { const currentTopology = await mcp.swarm_status({ swarmId }); const optimizedTopology = await this.calculateOptimalTopology(currentTopology); if (optimizedTopology.improvement > 0.1) { // 10% improvement threshold await mcp.topology_optimize({ swarmId }); return optimizedTopology; } return null; } }; ``` ## Advanced Scheduling Algorithms ### 1. Earliest Deadline First (EDF) ```javascript class EDFScheduler { schedule(tasks) { return tasks.sort((a, b) => a.deadline - b.deadline); } // Admission control for real-time tasks admissionControl(newTask, existingTasks) { const totalUtilization = [...existingTasks, newTask] .reduce((sum, task) => sum + (task.executionTime / task.period), 0); return totalUtilization <= 1.0; // Liu & Layland bound } } ``` ### 2. Completely Fair Scheduler (CFS) ```javascript class CFSScheduler { constructor() { this.virtualRuntime = new Map(); this.weights = new Map(); this.rbtree = new RedBlackTree(); } schedule() { const nextTask = this.rbtree.minimum(); if (nextTask) { this.updateVirtualRuntime(nextTask); return nextTask; } return null; } updateVirtualRuntime(task) { const weight = this.weights.get(task.id) || 1; const runtime = this.virtualRuntime.get(task.id) || 0; this.virtualRuntime.set(task.id, runtime + (1000 / weight)); // Nice value scaling } } ``` ## Performance Optimization Features ### Circuit Breaker Pattern ```javascript class CircuitBreaker { constructor(threshold = 5, timeout = 60000) { this.failureThreshold = threshold; this.timeout = timeout; this.failureCount = 0; this.lastFailureTime = null; this.state = 'CLOSED'; // CLOSED, OPEN, HALF_OPEN } async execute(operation) { if (this.state === 'OPEN') { if (Date.now() - this.lastFailureTime > this.timeout) { this.state = 'HALF_OPEN'; } else { throw new Error('Circuit breaker is OPEN'); } } try { const result = await operation(); this.onSuccess(); return result; } catch (error) { this.onFailure(); throw error; } } onSuccess() { this.failureCount = 0; this.state = 'CLOSED'; } onFailure() { this.failureCount++; this.lastFailureTime = Date.now(); if (this.failureCount >= this.failureThreshold) { this.state = 'OPEN'; } } } ``` ## Operational Commands ### Load Balancing Commands ```bash # Initialize load balancer npx claude-flow agent spawn load-balancer --type coordinator # Start load balancing npx claude-flow load-balance --swarm-id <id> --strategy adaptive # Monitor load distribution npx claude-flow agent-metrics --type load-balancer # Adjust balancing parameters npx claude-flow config-manage --action update --config '{"stealThreshold": 5, "agingBoost": 10}' ``` ### Performance Monitoring ```bash # Real-time load monitoring npx claude-flow performance-report --format detailed # Bottleneck analysis npx claude-flow bottleneck-analyze --component swarm-coordination # Resource utilization tracking npx claude-flow metrics-collect --components ["load-balancer", "task-queue"] ``` ## Integration Points ### With Other Optimization Agents - **Performance Monitor**: Provides real-time metrics for load balancing decisions - **Topology Optimizer**: Coordinates topology changes based on load patterns - **Resource Allocator**: Optimizes resource distribution across the swarm ### With Swarm Infrastructure - **Task Orchestrator**: Receives load-balanced task assignments - **Agent Coordinator**: Provides agent capacity and availability information - **Memory System**: Stores load balancing history and patterns ## Performance Metrics ### Key Performance Indicators - **Load Distribution Variance**: Measure of load balance across agents - **Task Migration Rate**: Frequency of work-stealing operations - **Queue Latency**: Average time tasks spend in queues - **Utilization Efficiency**: Percentage of optimal resource utilization - **Fairness Index**: Measure of fair resource allocation ### Benchmarking ```javascript // Load balancer benchmarking suite const benchmarks = { async throughputTest(taskCount, agentCount) { const startTime = performance.now(); await this.distributeAndExecute(taskCount, agentCount); const endTime = performance.now(); return { throughput: taskCount / ((endTime - startTime) / 1000), averageLatency: (endTime - startTime) / taskCount }; }, async loadBalanceEfficiency(tasks, agents) { const distribution = await this.distributeLoad(tasks, agents); const idealLoad = tasks.length / agents.length; const variance = distribution.reduce((sum, load) => sum + Math.pow(load - idealLoad, 2), 0) / agents.length; return { efficiency: 1 / (1 + variance), loadVariance: variance }; } }; ``` This Load Balancing Coordinator agent provides comprehensive task distribution optimization with advanced algorithms, real-time monitoring, and adaptive resource allocation capabilities for high-performance swarm coordination.