Multi-Agent Systems

What are Multi-Agent Systems?

Multi-agent systems involve multiple AI agents working together to accomplish complex tasks. Each agent has specialized capabilities, and they communicate and coordinate to achieve shared goals.

Agent Communication Patterns

from typing import List, Dict, Any
from dataclasses import dataclass
from enum import Enum

class MessageType(Enum):
    REQUEST = "request"
    RESPONSE = "response"
    BROADCAST = "broadcast"

@dataclass
class Message:
    sender: str
    receiver: str
    content: Dict[str, Any]
    msg_type: MessageType

class MultiAgentSystem:
    def __init__(self):
        self.agents: Dict[str, Agent] = {}
        self.message_queue: List[Message] = []

    def register_agent(self, name: str, agent: Agent):
        self.agents[name] = agent

    def send_message(self, message: Message):
        self.message_queue.append(message)

    def process_messages(self):
        while self.message_queue:
            message = self.message_queue.pop(0)
            agent = self.agents.get(message.receiver)
            if agent:
                response = agent.receive_message(message)
                if response:
                    self.send_message(response)

Orchestration Patterns

class OrchestratorPattern:
    """Central coordinator manages all agents."""

    def __init__(self, coordinator: Agent, workers: List[Agent]):
        self.coordinator = coordinator
        self.workers = workers

    def execute(self, task):
        # Coordinator breaks down task
        subtasks = self.coordinator.decompose(task)

        # Distribute to workers
        results = []
        for subtask in subtasks:
            worker = self.assign_worker(subtask)
            result = worker.execute(subtask)
            results.append(result)

        # Coordinator synthesizes results
        return self.coordinator.synthesize(results)

class CollaborativePattern:
    """Agents work together as peers."""

    def __init__(self, agents: List[Agent]):
        self.agents = agents

    def execute(self, task):
        # Each agent contributes
        contributions = []
        for agent in self.agents:
            contribution = agent.contribute(task)
            contributions.append(contribution)

        # Agents negotiate final answer
        return self.negotiate(contributions)

Specialized Agent Types

Summary

Multi-agent systems enable complex task completion through specialization and collaboration. They're essential for building sophisticated AI workflows.

Next: We'll explore code generation models.