Agent skill for load-balancer - invoke with $agent-load-balancer
npxskills add ruvnet/claude-flow--skill agent-load-balancerLoading…
// 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);
}
};
// 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;
});
}
};
// 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;
}
});
}
}
}
// 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 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;
}
};
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
}
}
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
}
}
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';
}
}
}
# 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}'
# 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"]
// 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.
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.