Coordination Patterns
Core Principles:
Autonomy + Coordination + Communication = Emergent Intelligence
Autonomy + Coordination + Communication = Emergent Intelligence
Hierarchical Coordination
Manager agents delegate tasks to worker agents with clear command structure
Peer-to-Peer Collaboration
Equal agents negotiate and coordinate through consensus mechanisms
Market-Based Coordination
Agents bid for tasks and resources using economic principles
Swarm Intelligence
Simple agents follow local rules to achieve global optimization
Blackboard Systems
Shared knowledge space where agents contribute and consume information
Multi-Agent System Implementation
class MultiAgentSystem:
def __init__(self):
self.agents = {}
self.message_bus = MessageBus()
self.coordinator = Coordinator()
self.shared_memory = SharedMemory()
def add_agent(self, agent_id, agent):
"""Register a new agent in the system"""
self.agents[agent_id] = agent
agent.set_system_context(self.message_bus, self.shared_memory)
def broadcast_message(self, sender_id, message):
"""Send message to all agents"""
for agent_id, agent in self.agents.items():
if agent_id != sender_id:
agent.receive_message(sender_id, message)
def coordinate_task(self, task):
"""Coordinate task execution across agents"""
# Decompose task into subtasks
subtasks = self.coordinator.decompose_task(task)
# Assign subtasks to appropriate agents
assignments = self.coordinator.assign_tasks(subtasks, self.agents)
# Execute with coordination
results = {}
for agent_id, subtask in assignments.items():
agent = self.agents[agent_id]
results[agent_id] = agent.execute_task(subtask)
# Aggregate results
return self.coordinator.aggregate_results(results)
class CollaborativeAgent:
def __init__(self, agent_id, capabilities):
self.agent_id = agent_id
self.capabilities = capabilities
self.message_bus = None
self.shared_memory = None
self.peers = set()
def set_system_context(self, message_bus, shared_memory):
self.message_bus = message_bus
self.shared_memory = shared_memory
def negotiate_task(self, task):
"""Negotiate task assignment with peers"""
# Assess own capability for task
capability_score = self.assess_capability(task)
# Request peer capabilities
peer_scores = {}
for peer_id in self.peers:
response = self.message_bus.send_request(
peer_id,
{"type": "capability_query", "task": task}
)
peer_scores[peer_id] = response.get("score", 0)
# Decide on task assignment
best_agent = max(
{self.agent_id: capability_score, **peer_scores}.items(),
key=lambda x: x[1]
)[0]
return best_agent == self.agent_id
def collaborate_on_task(self, task):
"""Collaborate with other agents on complex task"""
# Share task context
self.shared_memory.store(f"task_{task.id}", {
"description": task.description,
"requirements": task.requirements,
"progress": 0
})
# Request collaboration
collaborators = self.find_collaborators(task)
# Coordinate execution
my_part = self.determine_my_contribution(task, collaborators)
result = self.execute_task_part(my_part)
# Share results and wait for others
self.shared_memory.update(f"task_{task.id}", {
f"result_{self.agent_id}": result
})
# Wait for all collaborators to complete
final_result = self.wait_for_completion(task.id, collaborators)
return final_result
# Example: Research team system
class ResearchTeam(MultiAgentSystem):
def __init__(self):
super().__init__()
# Add specialized research agents
self.add_agent("data_collector", DataCollectorAgent())
self.add_agent("analyst", AnalystAgent())
self.add_agent("writer", WriterAgent())
self.add_agent("reviewer", ReviewerAgent())
def conduct_research(self, topic):
"""Coordinate research project across team"""
research_task = ResearchTask(topic)
# Phase 1: Data collection
data = self.agents["data_collector"].collect_data(topic)
# Phase 2: Analysis
analysis = self.agents["analyst"].analyze_data(data)
# Phase 3: Writing
draft = self.agents["writer"].write_report(analysis)
# Phase 4: Review and refinement
final_report = self.agents["reviewer"].review_and_improve(draft)
return final_report
# Usage example
team = ResearchTeam()
report = team.conduct_research("AI Agent Architectures")