Multi-Agent Systems

User: "Write a product launch plan"
       ↓
Supervisor Agent:
  - Breaks into: Market Analysis, Budget Planning, Timeline, Risk Mitigation
  - Assigns to specialists
       ↓
Market Analyst: "Competitors, target audience, positioning"
Budget Planner: "Cost breakdown, revenue projections"
Timeline Manager: "Phases, milestones, dependencies"
Risk Analyst: "Risks, mitigation strategies"
       ↓
Supervisor: Gathers results, synthesizes into final plan
       ↓
User: Complete launch plan

class Agent:
    def __init__(self, name: str, role: str):
        self.name = name
        self.role = role
        self.client = anthropic.Anthropic()

    def work(self, task: str) -> str:
        """Execute a task and return result."""
        response = self.client.messages.create(
            model="claude-opus-4-6",
            max_tokens=2048,
            system=f"You are a {self.role}. Your name is {self.name}. Do excellent work.",
            messages=[{"role": "user", "content": task}]
        )
        return response.content[0].text

class SupervisorAgent:
    def __init__(self):
        self.supervisor = Agent("Supervisor", "Project Manager")
        self.specialists = [
            Agent("Alice", "Market Research Analyst"),
            Agent("Bob", "Financial Analyst"),
            Agent("Carol", "Project Manager")
        ]

    def run(self, goal: str) -> str:
        """Supervisor breaks goal into subtasks, delegates to specialists."""

        # 1. Supervisor analyzes goal and creates subtasks
        subtasks_prompt = f"""Goal: {goal}

Break this into 3 specific subtasks for different specialists:
1. For a Market Research Analyst
2. For a Financial Analyst
3. For a Project Manager

Format:
SUBTASK 1: [task for analyst 1]
SUBTASK 2: [task for analyst 2]
SUBTASK 3: [task for analyst 3]"""

        subtasks_text = self.supervisor.work(subtasks_prompt)

        # 2. Parse subtasks (simple regex approach)
        subtasks = []
        for line in subtasks_text.split("\n"):
            if "SUBTASK" in line:
                subtasks.append(line)

        # 3. Distribute to specialists
        results = []
        for i, specialist in enumerate(self.specialists):
            if i < len(subtasks):
                result = specialist.work(subtasks[i])
                results.append({
                    "specialist": specialist.name,
                    "result": result
                })

        # 4. Supervisor synthesizes results
        synthesis_prompt = f"""You have collected the following results from specialists:

{chr(10).join([f"{r['specialist']}: {r['result'][:300]}" for r in results])}

Synthesize these into a cohesive final deliverable for the goal: {goal}

Provide a comprehensive, well-structured final answer."""

        final_answer = self.supervisor.work(synthesis_prompt)
        return final_answer

# Usage
supervisor = SupervisorAgent()
result = supervisor.run("Create a launch strategy for a new SaaS product")
print(result)

class DebateAgents:
    def __init__(self):
        self.pro_agent = Agent("Pro", "Advocates FOR the proposal")
        self.con_agent = Agent("Con", "Advocates AGAINST the proposal")
        self.judge = Agent("Judge", "Evaluates both sides fairly")

    def debate(self, question: str) -> str:
        # Round 1: Pro argues FOR
        pro_argument = self.pro_agent.work(
            f"Argue STRONGLY FOR: {question}\nBe compelling and data-driven."
        )

        # Round 2: Con argues AGAINST
        con_argument = self.con_agent.work(
            f"Argue STRONGLY AGAINST: {question}\nAddress Pro's points if possible."
        )

        # Round 3: Judge decides
        judgment = self.judge.work(
            f"""Question: {question}

Pro argument: {pro_argument}

Con argument: {con_argument}

Evaluate both arguments. Which is stronger? Why? What's the best decision?"""
        )

        return f"""
PRO ARGUMENT:
{pro_argument}

CON ARGUMENT:
{con_argument}

JUDGE'S DECISION:
{judgment}"""

# Usage
debate = DebateAgents()
decision = debate.debate("Should we adopt microservices architecture?")
print(decision)