InteractiveBenefits and Challenges of Multi-Agent Systems: When Complexity is Worth It

1## Using GPT-5 for a generalist customer service agent
2import openai
3
4client = openai.OpenAI(api_key="OPENAI_API_KEY")
5
6def generalist_agent(customer_query):
7    """
8    A single agent that tries to handle all customer service tasks.
9    """
10    system_prompt = """You are a customer service agent. Handle:
11    - Technical support questions
12    - Billing inquiries
13    - Product recommendations
14    - Returns and refunds
15    - Account management
16    
17    Be helpful and professional."""
18    
19    response = client.chat.completions.create(
20        model="gpt-5",
21        messages=[
22            {"role": "system", "content": system_prompt},
23            {"role": "user", "content": customer_query}
24        ]
25    )
26    
27    return response.choices[0].message.content
28
29## Example queries
30print("Query 1:", generalist_agent("My payment failed but I was still charged"))
31print("\nQuery 2:", generalist_agent("Which laptop is best for video editing?"))
32print("\nQuery 3:", generalist_agent("How do I reset my password?"))

1## Using Claude Sonnet 4.5 for specialized customer service agents
2import anthropic
3
4client = anthropic.Anthropic(api_key="ANTHROPIC_API_KEY")
5
6class SpecializedCustomerService:
7    """
8    Customer service system with specialized agents.
9    """
10    def __init__(self):
11        self.model = "claude-sonnet-4.5"
12    
13    def router_agent(self, query):
14        """
15        Routes queries to the appropriate specialist.
16        """
17        system_prompt = """You are a routing specialist. Categorize customer queries:
18        - technical: password resets, login issues, bugs
19        - billing: payments, charges, refunds, invoices
20        - products: recommendations, specifications, comparisons
21        - returns: return requests, warranty claims, exchanges
22        
23        Return only the category name, nothing else."""
24        
25        response = client.messages.create(
26            model=self.model,
27            max_tokens=50,
28            system=system_prompt,
29            messages=[{"role": "user", "content": query}]
30        )
31        
32        return response.content[0].text.strip().lower()
33    
34    def technical_agent(self, query):
35        """
36        Specialist in technical support.
37        """
38        system_prompt = """You are a technical support specialist.
39        You have deep knowledge of:
40        - Authentication systems and password resets
41        - Common technical issues and troubleshooting
42        - System requirements and compatibility
43        
44        Provide clear, step-by-step technical guidance."""
45        
46        response = client.messages.create(
47            model=self.model,
48            max_tokens=512,
49            system=system_prompt,
50            messages=[{"role": "user", "content": query}]
51        )
52        
53        return response.content[0].text
54    
55    def billing_agent(self, query):
56        """
57        Specialist in billing and payments.
58        """
59        system_prompt = """You are a billing specialist.
60        You have deep knowledge of:
61        - Payment processing and failed transactions
62        - Refund policies and procedures
63        - Invoice questions and billing disputes
64        
65        Be empathetic and clear about financial matters."""
66        
67        response = client.messages.create(
68            model=self.model,
69            max_tokens=512,
70            system=system_prompt,
71            messages=[{"role": "user", "content": query}]
72        )
73        
74        return response.content[0].text
75    
76    def product_agent(self, query):
77        """
78        Specialist in product recommendations.
79        """
80        system_prompt = """You are a product specialist.
81        You have deep knowledge of:
82        - Product specifications and features
83        - Use case matching and recommendations
84        - Competitive comparisons
85        
86        Help customers find the right product for their needs."""
87        
88        response = client.messages.create(
89            model=self.model,
90            max_tokens=512,
91            system=system_prompt,
92            messages=[{"role": "user", "content": query}]
93        )
94        
95        return response.content[0].text
96    
97    def handle_query(self, query):
98        """
99        Route and handle a customer query.
100        """
101        # Determine the right specialist
102        category = self.router_agent(query)
103        print(f"Routing to: {category} specialist")
104        
105        # Delegate to the specialist
106        if "technical" in category:
107            return self.technical_agent(query)
108        elif "billing" in category:
109            return self.billing_agent(query)
110        elif "product" in category:
111            return self.product_agent(query)
112        else:
113            return "I'll connect you with the right specialist."
114
115## Example usage
116service = SpecializedCustomerService()
117
118print("=== Customer Service with Specialized Agents ===\n")
119
120queries = [
121    "My payment failed but I was still charged",
122    "Which laptop is best for video editing?",
123    "How do I reset my password?"
124]
125
126for query in queries:
127    print(f"\nCustomer: {query}")
128    response = service.handle_query(query)
129    print(f"Agent: {response[:100]}...")  # Truncate for readability

1## Using Claude Sonnet 4.5 for parallel agent execution
2import anthropic
3import concurrent.futures
4import time
5
6client = anthropic.Anthropic(api_key="ANTHROPIC_API_KEY")
7
8def flight_agent(destination, dates):
9    """
10    Researches flight options.
11    """
12    start = time.time()
13    
14    system_prompt = """You are a flight research specialist.
15    Find the best flight options considering price, duration, and convenience."""
16    
17    query = f"Find flights to {destination} for {dates}"
18    
19    response = client.messages.create(
20        model="claude-sonnet-4.5",
21        max_tokens=512,
22        system=system_prompt,
23        messages=[{"role": "user", "content": query}]
24    )
25    
26    elapsed = time.time() - start
27    return {
28        "agent": "flights",
29        "result": response.content[0].text,
30        "time": elapsed
31    }
32
33def hotel_agent(destination, dates):
34    """
35    Researches hotel options.
36    """
37    start = time.time()
38    
39    system_prompt = """You are a hotel research specialist.
40    Find the best hotel options considering location, amenities, and value."""
41    
42    query = f"Find hotels in {destination} for {dates}"
43    
44    response = client.messages.create(
45        model="claude-sonnet-4.5",
46        max_tokens=512,
47        system=system_prompt,
48        messages=[{"role": "user", "content": query}]
49    )
50    
51    elapsed = time.time() - start
52    return {
53        "agent": "hotels",
54        "result": response.content[0].text,
55        "time": elapsed
56    }
57
58def activities_agent(destination, interests):
59    """
60    Researches activities and attractions.
61    """
62    start = time.time()
63    
64    system_prompt = """You are a local activities specialist.
65    Recommend activities, restaurants, and attractions based on interests."""
66    
67    query = f"Recommend activities in {destination} for someone interested in {interests}"
68    
69    response = client.messages.create(
70        model="claude-sonnet-4.5",
71        max_tokens=512,
72        system=system_prompt,
73        messages=[{"role": "user", "content": query}]
74    )
75    
76    elapsed = time.time() - start
77    return {
78        "agent": "activities",
79        "result": response.content[0].text,
80        "time": elapsed
81    }
82
83## Sequential execution (single agent approach)
84def plan_trip_sequential(destination, dates, interests):
85    """
86    Plan a trip with one agent doing everything sequentially.
87    """
88    print("=== Sequential Planning ===")
89    total_start = time.time()
90    
91    results = []
92    results.append(flight_agent(destination, dates))
93    results.append(hotel_agent(destination, dates))
94    results.append(activities_agent(destination, interests))
95    
96    total_time = time.time() - total_start
97    
98    for r in results:
99        print(f"{r['agent']}: {r['time']:.2f}s")
100    print(f"Total time: {total_time:.2f}s\n")
101    
102    return results
103
104## Parallel execution (multi-agent approach)
105def plan_trip_parallel(destination, dates, interests):
106    """
107    Plan a trip with multiple agents working simultaneously.
108    """
109    print("=== Parallel Planning ===")
110    total_start = time.time()
111    
112    # Execute all agents concurrently
113    with concurrent.futures.ThreadPoolExecutor(max_workers=3) as executor:
114        flight_future = executor.submit(flight_agent, destination, dates)
115        hotel_future = executor.submit(hotel_agent, destination, dates)
116        activities_future = executor.submit(activities_agent, destination, interests)
117        
118        # Wait for all to complete
119        results = [
120            flight_future.result(),
121            hotel_future.result(),
122            activities_future.result()
123        ]
124    
125    total_time = time.time() - total_start
126    
127    for r in results:
128        print(f"{r['agent']}: {r['time']:.2f}s")
129    print(f"Total time: {total_time:.2f}s\n")
130    
131    return results
132
133## Compare both approaches
134sequential_results = plan_trip_sequential("Tokyo", "March 15-22", "food and history")
135parallel_results = plan_trip_parallel("Tokyo", "March 15-22", "food and history")
136
137## Calculate speedup
138seq_time = sum(r['time'] for r in sequential_results)
139par_time = max(r['time'] for r in parallel_results)
140speedup = seq_time / par_time
141
142print(f"Speedup: {speedup:.2f}x faster with parallel agents")

1## Using Claude Sonnet 4.5 for agent verification
2import anthropic
3import json
4
5client = anthropic.Anthropic(api_key="ANTHROPIC_API_KEY")
6
7def research_agent(topic):
8    """
9    Researches a topic and provides findings.
10    """
11    system_prompt = """You are a research agent. Research the topic and provide factual information.
12    Return your findings as JSON with:
13    - claims: list of factual claims you're making
14    - confidence: your confidence level (0-1) for each claim
15    - sources: where this information comes from"""
16    
17    response = client.messages.create(
18        model="claude-sonnet-4.5",
19        max_tokens=1024,
20        system=system_prompt,
21        messages=[{"role": "user", "content": f"Research: {topic}"}]
22    )
23    
24    return response.content[0].text
25
26def verification_agent(research_findings):
27    """
28    Verifies research findings for accuracy and completeness.
29    """
30    system_prompt = """You are a fact-checking agent. Review research findings and:
31    - Check if claims are well-supported
32    - Identify any potential errors or inconsistencies
33    - Suggest additional information needed
34    - Rate overall reliability
35    
36    Return JSON with:
37    - verified_claims: claims that seem accurate
38    - questionable_claims: claims that need more verification
39    - missing_information: important gaps in the research
40    - overall_confidence: your confidence in the research (0-1)"""
41    
42    response = client.messages.create(
43        model="claude-sonnet-4.5",
44        max_tokens=1024,
45        system=system_prompt,
46        messages=[{"role": "user", "content": f"Verify this research:\n\n{research_findings}"}]
47    )
48    
49    return response.content[0].text
50
51def synthesis_agent(research, verification):
52    """
53    Synthesizes verified information into a final answer.
54    """
55    system_prompt = """You are a synthesis agent. Combine research and verification to create a final answer.
56    Include only well-verified information. Acknowledge uncertainties.
57    Be clear about confidence levels."""
58    
59    context = f"Research:\n{research}\n\nVerification:\n{verification}"
60    
61    response = client.messages.create(
62        model="claude-sonnet-4.5",
63        max_tokens=1024,
64        system=system_prompt,
65        messages=[{"role": "user", "content": f"Synthesize:\n\n{context}"}]
66    )
67    
68    return response.content[0].text
69
70## Example: Research with verification
71def research_with_verification(topic):
72    """
73    Multi-agent research with built-in verification.
74    """
75    print(f"=== Researching: {topic} ===\n")
76    
77    # Step 1: Initial research
78    print("Research Agent working...")
79    research = research_agent(topic)
80    print(f"Research completed:\n{research[:200]}...\n")
81    
82    # Step 2: Verification
83    print("Verification Agent checking...")
84    verification = verification_agent(research)
85    print(f"Verification completed:\n{verification[:200]}...\n")
86    
87    # Step 3: Final synthesis
88    print("Synthesis Agent combining results...")
89    final_answer = synthesis_agent(research, verification)
90    print(f"Final Answer:\n{final_answer}")
91    
92    return final_answer
93
94## Run the verified research
95result = research_with_verification(
96    "What are the health benefits of intermittent fasting?"
97)

1## Using Claude Sonnet 4.5 to demonstrate coordination challenges
2import anthropic
3import time
4
5client = anthropic.Anthropic(api_key="ANTHROPIC_API_KEY")
6
7class ReportWritingTeam:
8    """
9    Three agents collaborating on a report (with potential coordination issues).
10    """
11    def __init__(self):
12        self.model = "claude-sonnet-4.5"
13        self.shared_state = {
14            "outline": None,
15            "sections": {},
16            "final_report": None
17        }
18    
19    def outlining_agent(self, topic):
20        """
21        Creates a report outline.
22        """
23        system_prompt = """You are an outlining specialist.
24        Create a clear outline for a report on the given topic.
25        Return a simple numbered list of sections."""
26        
27        response = client.messages.create(
28            model=self.model,
29            max_tokens=512,
30            system=system_prompt,
31            messages=[{"role": "user", "content": f"Create outline for: {topic}"}]
32        )
33        
34        self.shared_state["outline"] = response.content[0].text
35        return self.shared_state["outline"]
36    
37    def writing_agent(self, section_number):
38        """
39        Writes a specific section of the report.
40        """
41        # Problem: What if the outline isn't ready yet?
42        outline = self.shared_state.get("outline")
43        if not outline:
44            return "ERROR: No outline available yet!"
45        
46        system_prompt = f"""You are a writing specialist.
47        Write section {section_number} based on this outline:\n\n{outline}"""
48        
49        response = client.messages.create(
50            model=self.model,
51            max_tokens=1024,
52            system=system_prompt,
53            messages=[{"role": "user", "content": f"Write section {section_number}"}]
54        )
55        
56        section_text = response.content[0].text
57        self.shared_state["sections"][section_number] = section_text
58        return section_text
59    
60    def editing_agent(self):
61        """
62        Edits and finalizes the report.
63        """
64        # Problem: What if sections aren't ready yet?
65        sections = self.shared_state.get("sections")
66        if not sections:
67            return "ERROR: No sections to edit yet!"
68        
69        combined = "\n\n".join([
70            f"Section {num}:\n{text}" 
71            for num, text in sorted(sections.items())
72        ])
73        
74        system_prompt = """You are an editing specialist.
75        Review and polish this report for clarity and flow."""
76        
77        response = client.messages.create(
78            model=self.model,
79            max_tokens=2048,
80            system=system_prompt,
81            messages=[{"role": "user", "content": combined}]
82        )
83        
84        self.shared_state["final_report"] = response.content[0].text
85        return self.shared_state["final_report"]
86
87## Example: What happens with poor coordination?
88def write_report_poor_coordination(topic):
89    """
90    Demonstrates coordination problems when agents aren't synchronized.
91    """
92    team = ReportWritingTeam()
93    
94    print("=== Poor Coordination Example ===\n")
95    
96    # Problem: Starting all agents at once without coordination
97    import concurrent.futures
98    
99    with concurrent.futures.ThreadPoolExecutor(max_workers=3) as executor:
100        # All agents start simultaneously
101        outline_future = executor.submit(team.outlining_agent, topic)
102        writing_future = executor.submit(team.writing_agent, 1)
103        editing_future = executor.submit(team.editing_agent)
104        
105        # Results
106        outline = outline_future.result()
107        section = writing_future.result()
108        final = editing_future.result()
109    
110    print(f"Outline: {outline[:100]}...")
111    print(f"Section: {section[:100]}...")
112    print(f"Final: {final[:100]}...")
113    print("\nNotice the errors: writing and editing agents failed because they started before outline was ready!")
114
115## Example: Better coordination
116def write_report_good_coordination(topic):
117    """
118    Demonstrates proper coordination with sequencing.
119    """
120    team = ReportWritingTeam()
121    
122    print("\n=== Good Coordination Example ===\n")
123    
124    # Step 1: Outline first
125    print("Step 1: Creating outline...")
126    outline = team.outlining_agent(topic)
127    print(f"Outline ready: {outline[:100]}...\n")
128    
129    # Step 2: Write sections (could be parallel if multiple sections)
130    print("Step 2: Writing sections...")
131    section = team.writing_agent(1)
132    print(f"Section complete: {section[:100]}...\n")
133    
134    # Step 3: Edit the complete report
135    print("Step 3: Editing final report...")
136    final = team.editing_agent()
137    print(f"Final report: {final[:100]}...\n")
138    
139    print("Success: Proper sequencing avoided coordination errors!")
140
141## Demonstrate both approaches
142write_report_poor_coordination("The Future of Renewable Energy")
143write_report_good_coordination("The Future of Renewable Energy")

1User Question: "What's the weather in Paris next Tuesday?"
2
3Single Agent System:
4- User $\to$ Agent $\to$ Weather API $\to$ Agent $\to$ User
5- Debug: Check agent's API call and response
6
7Multi-Agent System:
8- User $\to$ Router Agent $\to$ Intent Agent $\to$ Scheduling Agent $\to$ Weather Agent $\to$ Response Agent $\to$ User
9- Debug: Which agent failed? What did each agent pass to the next?
10- Check router's categorization
11- Check intent extraction
12- Check date parsing
13- Check weather API call
14- Check response formatting
15- Trace message flow between all agents

1## Using Claude Sonnet 4.5 to demonstrate communication misunderstandings
2import anthropic
3import json
4
5client = anthropic.Anthropic(api_key="ANTHROPIC_API_KEY")
6
7def data_agent():
8    """
9    Agent that provides data (but in an ambiguous format).
10    """
11    system_prompt = """You are a data collection agent.
12    Provide the requested data in a clear format."""
13    
14    response = client.messages.create(
15        model="claude-sonnet-4.5",
16        max_tokens=256,
17        system=system_prompt,
18        messages=[{"role": "user", "content": "Provide the quarterly revenue figures"}]
19    )
20    
21    return response.content[0].text
22
23def analysis_agent(data):
24    """
25    Agent that analyzes data (expecting specific format).
26    """
27    system_prompt = """You are a data analysis agent.
28    You receive data as JSON with fields: q1, q2, q3, q4 (all numbers).
29    Calculate the total and average."""
30    
31    # Problem: What if data isn't in the expected format?
32    try:
33        data_dict = json.loads(data)
34        total = sum(data_dict.values())
35        average = total / len(data_dict)
36        return f"Total: ${total:,.0f}, Average: ${average:,.0f}"
37    except:
38        return "ERROR: Could not parse data. Expected JSON format with quarterly numbers."
39
40## Demonstrate the communication issue
41print("=== Communication Misunderstanding ===\n")
42
43data = data_agent()
44print(f"Data Agent provided:\n{data}\n")
45
46result = analysis_agent(data)
47print(f"Analysis Agent result:\n{result}\n")
48
49print("Problem: If Data Agent didn't return strict JSON, Analysis Agent fails!")