Benefits and Challenges of Multi-Agent Systems › The Challenges of Multi-Agent Systems

## Using Claude Sonnet 4.5 to demonstrate coordination challenges
import os
from anthropic import Anthropic
import time

client = Anthropic(api_key=os.getenv("ANTHROPIC_API_KEY"))

class ReportWritingTeam:
    """
    Three agents collaborating on a report (with potential coordination issues).
    """
    def __init__(self):
        self.model = "claude-sonnet-4-5"
        self.shared_state = {
            "outline": None,
            "sections": {},
            "final_report": None
        }
    
    def outlining_agent(self, topic):
        """
        Creates a report outline.
        """
        system_prompt = """You are an outlining specialist.
        Create a clear outline for a report on the given topic.
        Return a simple numbered list of sections."""
        
        response = client.messages.create(
            model=self.model,
            max_tokens=512,
            system=system_prompt,
            messages=[{"role": "user", "content": f"Create outline for: {topic}"}]
        )
        
        self.shared_state["outline"] = response.content[0].text
        return self.shared_state["outline"]
    
    def writing_agent(self, section_number):
        """
        Writes a specific section of the report.
        """
        # Problem: What if the outline isn't ready yet?
        outline = self.shared_state.get("outline")
        if not outline:
            return "ERROR: No outline available yet!"
        
        system_prompt = f"""You are a writing specialist.
        Write section {section_number} based on this outline:\n\n{outline}"""
        
        response = client.messages.create(
            model=self.model,
            max_tokens=1024,
            system=system_prompt,
            messages=[{"role": "user", "content": f"Write section {section_number}"}]
        )
        
        section_text = response.content[0].text
        self.shared_state["sections"][section_number] = section_text
        return section_text
    
    def editing_agent(self):
        """
        Edits and finalizes the report.
        """
        # Problem: What if sections aren't ready yet?
        sections = self.shared_state.get("sections")
        if not sections:
            return "ERROR: No sections to edit yet!"
        
        combined = "\n\n".join([
            f"Section {num}:\n{text}" 
            for num, text in sorted(sections.items())
        ])
        
        system_prompt = """You are an editing specialist.
        Review and polish this report for clarity and flow."""
        
        response = client.messages.create(
            model=self.model,
            max_tokens=2048,
            system=system_prompt,
            messages=[{"role": "user", "content": combined}]
        )
        
        self.shared_state["final_report"] = response.content[0].text
        return self.shared_state["final_report"]

## Example: What happens with poor coordination?
def write_report_poor_coordination(topic):
    """
    Demonstrates coordination problems when agents aren't synchronized.
    """
    team = ReportWritingTeam()
    
    print("=== Poor Coordination Example ===\n")
    
    # Problem: Starting all agents at once without coordination
    import concurrent.futures
    
    with concurrent.futures.ThreadPoolExecutor(max_workers=3) as executor:
        # All agents start simultaneously
        outline_future = executor.submit(team.outlining_agent, topic)
        writing_future = executor.submit(team.writing_agent, 1)
        editing_future = executor.submit(team.editing_agent)
        
        # Results
        outline = outline_future.result()
        section = writing_future.result()
        final = editing_future.result()
    
    print(f"Outline: {outline[:100]}...")
    print(f"Section: {section[:100]}...")
    print(f"Final: {final[:100]}...")
    print("\nNotice the errors: writing and editing agents failed because they started before outline was ready!")

## Example: Better coordination
def write_report_good_coordination(topic):
    """
    Demonstrates proper coordination with sequencing.
    """
    team = ReportWritingTeam()
    
    print("\n=== Good Coordination Example ===\n")
    
    # Step 1: Outline first
    print("Step 1: Creating outline...")
    outline = team.outlining_agent(topic)
    print(f"Outline ready: {outline[:100]}...\n")
    
    # Step 2: Write sections (could be parallel if multiple sections)
    print("Step 2: Writing sections...")
    section = team.writing_agent(1)
    print(f"Section complete: {section[:100]}...\n")
    
    # Step 3: Edit the complete report
    print("Step 3: Editing final report...")
    final = team.editing_agent()
    print(f"Final report: {final[:100]}...\n")
    
    print("Success: Proper sequencing avoided coordination errors!")

## Demonstrate both approaches
write_report_poor_coordination("The Future of Renewable Energy")
write_report_good_coordination("The Future of Renewable Energy")

## Using Claude Sonnet 4.5 to demonstrate communication misunderstandings
import os
from anthropic import Anthropic
import json

client = Anthropic(api_key=os.getenv("ANTHROPIC_API_KEY"))

def data_agent():
    """
    Agent that provides data (but in an ambiguous format).
    """
    system_prompt = """You are a data collection agent.
    Provide the requested data in a clear format."""
    
    response = client.messages.create(
        model="claude-sonnet-4-5",
        max_tokens=256,
        system=system_prompt,
        messages=[{"role": "user", "content": "Provide the quarterly revenue figures"}]
    )
    
    return response.content[0].text

def analysis_agent(data):
    """
    Agent that analyzes data (expecting specific format).
    """
    system_prompt = """You are a data analysis agent.
    You receive data as JSON with fields: q1, q2, q3, q4 (all numbers).
    Calculate the total and average."""
    
    # Problem: What if data isn't in the expected format?
    try:
        data_dict = json.loads(data)
        total = sum(data_dict.values())
        average = total / len(data_dict)
        return f"Total: ${total:,.0f}, Average: ${average:,.0f}"
    except:
        return "ERROR: Could not parse data. Expected JSON format with quarterly numbers."

## Demonstrate the communication issue
print("=== Communication Misunderstanding ===\n")

data = data_agent()
print(f"Data Agent provided:\n{data}\n")

result = analysis_agent(data)
print(f"Analysis Agent result:\n{result}\n")

print("Problem: If Data Agent didn't return strict JSON, Analysis Agent fails!")