设计与 UI
agent-task-delegation
Design and operate task delegation systems for multi-agent fleets. Covers workload distribution, load balancing, queue management, priority scheduling, and dynamic agent scaling for production agent systems.
cosmicstack-labs · 已有 AI 审核记录
安装与使用
运行命令前先阅读来源与依赖说明。复制命令不会自动安装或执行。
npx skills add cosmicstack-labs/mercury-agent-skills --skill agent-task-delegation技能说明
name: agent-task-delegation description: 'Design and operate task delegation systems for multi-agent fleets. Covers workload distribution, load balancing, queue management, priority scheduling, and dynamic agent scaling for production agent systems.' metadata: author: cosmicstack-labs version: 1.0.0 category: ai-ml tags: - task-delegation - load-balancing - queue-management - workload-distribution - agent-orchestration - scaling
Agent Task Delegation & Load Balancing
Overview
A multi-agent system without delegation logic is a mob, not a team. Tasks must be routed to the right agent, prioritized correctly, and balanced across available capacity. This skill covers queue-based architectures, routing strategies, backpressure handling, and dynamic scaling for production agent workloads.
Core Concepts
Delegation Models
| Model | Description | Best For |
|---|---|---|
| Direct Assignment | Task is routed to a specific agent by name | Known, fixed responsibilities |
| Work Queue | Tasks go into a queue; agents pull when ready | Variable workloads, many agents |
| Router | Classifier decides which agent handles each task | Heterogeneous task types |
| Supervisor | Orchestrator delegates and synthesizes | Complex multi-step workflows |
| Broadcast | All agents receive task; first responder claims it | Redundancy, SLA-critical tasks |
Load Balancing Strategies
| Strategy | Algorithm | When to Use |
|---|---|---|
| Round Robin | Cycle through agents in order | Identical agents, uniform tasks |
| Least Connections | Assign to agent with fewest active tasks | Variable task duration |
| Weighted | Based on agent capacity/priority | Heterogeneous agent capabilities |
| Consistent Hashing | Hash task → agent (deterministic) | Session affinity, cache locality |
| Latency-Based | Route to fastest available agent | Performance-sensitive tasks |
| Random | Pick agent at random | Simple, symmetrical setups |
Step-by-Step Implementation
Step 1: Build the Task Queue
from dataclasses import dataclass
from enum import Enum
import asyncio
import time
class Priority(Enum):
CRITICAL = 0
HIGH = 1
MEDIUM = 2
LOW = 3
@dataclass
class Task:
id: str
agent_type: str
payload: dict
priority: Priority = Priority.MEDIUM
created_at: float = None
timeout: int = 30
retry_count: int = 0
max_retries: int = 3
def __post_init__(self):
if self.created_at is None:
self.created_at = time.time()
class TaskQueue:
"""Priority-based task queue with timeout handling."""
def __init__(self):
self.queues = {
Priority.CRITICAL: asyncio.Queue(),
Priority.HIGH: asyncio.Queue(),
Priority.MEDIUM: asyncio.Queue(),
Priority.LOW: asyncio.Queue(),
}
async def enqueue(self, task: Task):
"""Add task to the appropriate priority queue."""
await self.queues[task.priority].put(task)
async def dequeue(self) -> Task:
"""Get the highest-priority available task."""
for priority in sorted([p for p in Priority]):
queue = self.queues[priority]
if not queue.empty():
task = await queue.get()
# Check if task has expired
if time.time() - task.created_at > task.timeout:
return await self.dequeue() # Skip expired task
return task
return None # All queues empty
Step 2: Implement the Delegator
class AgentDelegator:
"""Routes tasks to the right agent with load balancing."""
def __init__(self, task_queue: TaskQueue):
self.queue = task_queue
self.agents = {} # agent_type -> list of agent instances
self.active_tasks = {} # agent_id -> count
self.capacity = {} # agent_id -> max concurrent tasks
def register_agent(self, agent_type: str, agent, capacity: int = 5):
"""Register an agent that can handle tasks."""
if agent_type not in self.agents:
self.agents[agent_type] = []
agent_id = f"{agent_type}-{len(self.agents[agent_type])}"
agent.agent_id = agent_id
self.agents[agent_type].append(agent)
self.active_tasks[agent_id] = 0
self.capacity[agent_id] = capacity
async def delegate(self, task: Task) -> str:
"""Assign task to the best available agent."""
available = self._find_available(task.agent_type)
if not available:
# Backpressure — queue the task
await self.queue.enqueue(task)
return f"queued:{task.id}"
agent = self._select_agent(available)
self.active_tasks[agent.agent_id] += 1
try:
result = await asyncio.wait_for(
agent.run(task.payload),
timeout=task.timeout
)
return result
finally:
self.active_tasks[agent.agent_id] -= 1
def _find_available(self, agent_type: str) -> list:
"""Find agents with available capacity."""
available = []
for agent in self.agents.get(agent_type, []):
if self.active_tasks[agent.agent_id] < self.capacity[agent.agent_id]:
available.append(agent)
return available
def _select_agent(self, available: list):
"""Select the best agent using least-connections strategy."""
return min(available, key=lambda a: self.active_tasks[a.agent_id])
Step 3: Add Backpressure & Rate Limiting
class BackpressureManager:
"""Prevent overload with backpressure mechanisms."""
def __init__(self, max_queue_depth: int = 1000,
max_concurrent: int = 50):
self.max_queue_depth = max_queue
阅读完整来源 ↗