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
// 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
// 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
// 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
// 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
// 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)
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)
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
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
# 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
# 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
// 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.