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 &#x26;&#x26; !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 &#x26; 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.