Benefits and Challenges of Multi-Agent Systems › The Case for Multiple Agents

## Using GPT-5 for a generalist customer service agent
from openai import OpenAI
client = OpenAI(api_key=os.getenv("OPENAI_API_KEY"))

def generalist_agent(customer_query):
    """
    A single agent that tries to handle all customer service tasks.
    """
    system_prompt = """You are a customer service agent. Handle:
    - Technical support questions
    - Billing inquiries
    - Product recommendations
    - Returns and refunds
    - Account management
    
    Be helpful and professional."""
    
    response = client.chat.completions.create(
        model="gpt-5",
        messages=[
            {"role": "system", "content": system_prompt},
            {"role": "user", "content": customer_query}
        ]
    )
    
    return response.choices[0].message.content

## Example queries
print("Query 1:", generalist_agent("My payment failed but I was still charged"))
print("\nQuery 2:", generalist_agent("Which laptop is best for video editing?"))
print("\nQuery 3:", generalist_agent("How do I reset my password?"))

## Using Claude Sonnet 4.5 for specialized customer service agents
from anthropic import Anthropic
client = Anthropic(api_key=os.getenv("ANTHROPIC_API_KEY"))

class SpecializedCustomerService:
    """
    Customer service system with specialized agents.
    """
    def __init__(self):
        self.model = "claude-sonnet-4-5"
    
    def router_agent(self, query):
        """
        Routes queries to the appropriate specialist.
        """
        system_prompt = """You are a routing specialist. Categorize customer queries:
        - technical: password resets, login issues, bugs
        - billing: payments, charges, refunds, invoices
        - products: recommendations, specifications, comparisons
        - returns: return requests, warranty claims, exchanges
        
        Return only the category name, nothing else."""
        
        response = client.messages.create(
            model=self.model,
            max_tokens=50,
            system=system_prompt,
            messages=[{"role": "user", "content": query}]
        )
        
        return response.content[0].text.strip().lower()
    
    def technical_agent(self, query):
        """
        Specialist in technical support.
        """
        system_prompt = """You are a technical support specialist.
        You have deep knowledge of:
        - Authentication systems and password resets
        - Common technical issues and troubleshooting
        - System requirements and compatibility
        
        Provide clear, step-by-step technical guidance."""
        
        response = client.messages.create(
            model=self.model,
            max_tokens=512,
            system=system_prompt,
            messages=[{"role": "user", "content": query}]
        )
        
        return response.content[0].text
    
    def billing_agent(self, query):
        """
        Specialist in billing and payments.
        """
        system_prompt = """You are a billing specialist.
        You have deep knowledge of:
        - Payment processing and failed transactions
        - Refund policies and procedures
        - Invoice questions and billing disputes
        
        Be empathetic and clear about financial matters."""
        
        response = client.messages.create(
            model=self.model,
            max_tokens=512,
            system=system_prompt,
            messages=[{"role": "user", "content": query}]
        )
        
        return response.content[0].text
    
    def product_agent(self, query):
        """
        Specialist in product recommendations.
        """
        system_prompt = """You are a product specialist.
        You have deep knowledge of:
        - Product specifications and features
        - Use case matching and recommendations
        - Competitive comparisons
        
        Help customers find the right product for their needs."""
        
        response = client.messages.create(
            model=self.model,
            max_tokens=512,
            system=system_prompt,
            messages=[{"role": "user", "content": query}]
        )
        
        return response.content[0].text
    
    def handle_query(self, query):
        """
        Route and handle a customer query.
        """
        # Determine the right specialist
        category = self.router_agent(query)
        print(f"Routing to: {category} specialist")
        
        # Delegate to the specialist
        if "technical" in category:
            return self.technical_agent(query)
        elif "billing" in category:
            return self.billing_agent(query)
        elif "product" in category:
            return self.product_agent(query)
        else:
            return "I'll connect you with the right specialist."

## Example usage
service = SpecializedCustomerService()

print("=== Customer Service with Specialized Agents ===\n")

queries = [
    "My payment failed but I was still charged",
    "Which laptop is best for video editing?",
    "How do I reset my password?"
]

for query in queries:
    print(f"\nCustomer: {query}")
    response = service.handle_query(query)
    print(f"Agent: {response[:100]}...")  # Truncate for readability

## Using Claude Sonnet 4.5 for parallel agent execution
import os
from anthropic import Anthropic
import concurrent.futures
import time
client = Anthropic(api_key=os.getenv("ANTHROPIC_API_KEY"))

def flight_agent(destination, dates):
    """
    Researches flight options.
    """
    start = time.time()
    
    system_prompt = """You are a flight research specialist.
    Find the best flight options considering price, duration, and convenience."""
    
    query = f"Find flights to {destination} for {dates}"
    
    response = client.messages.create(
        model="claude-sonnet-4-5",
        max_tokens=512,
        system=system_prompt,
        messages=[{"role": "user", "content": query}]
    )
    
    elapsed = time.time() - start
    return {
        "agent": "flights",
        "result": response.content[0].text,
        "time": elapsed
    }

def hotel_agent(destination, dates):
    """
    Researches hotel options.
    """
    start = time.time()
    
    system_prompt = """You are a hotel research specialist.
    Find the best hotel options considering location, amenities, and value."""
    
    query = f"Find hotels in {destination} for {dates}"
    
    response = client.messages.create(
        model="claude-sonnet-4-5",
        max_tokens=512,
        system=system_prompt,
        messages=[{"role": "user", "content": query}]
    )
    
    elapsed = time.time() - start
    return {
        "agent": "hotels",
        "result": response.content[0].text,
        "time": elapsed
    }

def activities_agent(destination, interests):
    """
    Researches activities and attractions.
    """
    start = time.time()
    
    system_prompt = """You are a local activities specialist.
    Recommend activities, restaurants, and attractions based on interests."""
    
    query = f"Recommend activities in {destination} for someone interested in {interests}"
    
    response = client.messages.create(
        model="claude-sonnet-4-5",
        max_tokens=512,
        system=system_prompt,
        messages=[{"role": "user", "content": query}]
    )
    
    elapsed = time.time() - start
    return {
        "agent": "activities",
        "result": response.content[0].text,
        "time": elapsed
    }

## Sequential execution (single agent approach)
def plan_trip_sequential(destination, dates, interests):
    """
    Plan a trip with one agent doing everything sequentially.
    """
    print("=== Sequential Planning ===")
    total_start = time.time()
    
    results = []
    results.append(flight_agent(destination, dates))
    results.append(hotel_agent(destination, dates))
    results.append(activities_agent(destination, interests))
    
    total_time = time.time() - total_start
    
    for r in results:
        print(f"{r['agent']}: {r['time']:.2f}s")
    print(f"Total time: {total_time:.2f}s\n")
    
    return results

## Parallel execution (multi-agent approach)
def plan_trip_parallel(destination, dates, interests):
    """
    Plan a trip with multiple agents working simultaneously.
    """
    print("=== Parallel Planning ===")
    total_start = time.time()
    
    # Execute all agents concurrently
    with concurrent.futures.ThreadPoolExecutor(max_workers=3) as executor:
        flight_future = executor.submit(flight_agent, destination, dates)
        hotel_future = executor.submit(hotel_agent, destination, dates)
        activities_future = executor.submit(activities_agent, destination, interests)
        
        # Wait for all to complete
        results = [
            flight_future.result(),
            hotel_future.result(),
            activities_future.result()
        ]
    
    total_time = time.time() - total_start
    
    for r in results:
        print(f"{r['agent']}: {r['time']:.2f}s")
    print(f"Total time: {total_time:.2f}s\n")
    
    return results

## Compare both approaches
sequential_results = plan_trip_sequential("Tokyo", "March 15-22", "food and history")
parallel_results = plan_trip_parallel("Tokyo", "March 15-22", "food and history")

## Calculate speedup
seq_time = sum(r['time'] for r in sequential_results)
par_time = max(r['time'] for r in parallel_results)
speedup = seq_time / par_time

print(f"Speedup: {speedup:.2f}x faster with parallel agents")

## Using Claude Sonnet 4.5 for agent verification
import os
from anthropic import Anthropic
import json

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

def research_agent(topic):
    """
    Researches a topic and provides findings.
    """
    system_prompt = """You are a research agent. Research the topic and provide factual information.
    Return your findings as JSON with:
    - claims: list of factual claims you're making
    - confidence: your confidence level (0-1) for each claim
    - sources: where this information comes from"""
    
    response = client.messages.create(
        model="claude-sonnet-4-5",
        max_tokens=1024,
        system=system_prompt,
        messages=[{"role": "user", "content": f"Research: {topic}"}]
    )
    
    return response.content[0].text

def verification_agent(research_findings):
    """
    Verifies research findings for accuracy and completeness.
    """
    system_prompt = """You are a fact-checking agent. Review research findings and:
    - Check if claims are well-supported
    - Identify any potential errors or inconsistencies
    - Suggest additional information needed
    - Rate overall reliability
    
    Return JSON with:
    - verified_claims: claims that seem accurate
    - questionable_claims: claims that need more verification
    - missing_information: important gaps in the research
    - overall_confidence: your confidence in the research (0-1)"""
    
    response = client.messages.create(
        model="claude-sonnet-4-5",
        max_tokens=1024,
        system=system_prompt,
        messages=[{"role": "user", "content": f"Verify this research:\n\n{research_findings}"}]
    )
    
    return response.content[0].text

def synthesis_agent(research, verification):
    """
    Synthesizes verified information into a final answer.
    """
    system_prompt = """You are a synthesis agent. Combine research and verification to create a final answer.
    Include only well-verified information. Acknowledge uncertainties.
    Be clear about confidence levels."""
    
    context = f"Research:\n{research}\n\nVerification:\n{verification}"
    
    response = client.messages.create(
        model="claude-sonnet-4-5",
        max_tokens=1024,
        system=system_prompt,
        messages=[{"role": "user", "content": f"Synthesize:\n\n{context}"}]
    )
    
    return response.content[0].text

## Example: Research with verification
def research_with_verification(topic):
    """
    Multi-agent research with built-in verification.
    """
    print(f"=== Researching: {topic} ===\n")
    
    # Step 1: Initial research
    print("Research Agent working...")
    research = research_agent(topic)
    print(f"Research completed:\n{research[:200]}...\n")
    
    # Step 2: Verification
    print("Verification Agent checking...")
    verification = verification_agent(research)
    print(f"Verification completed:\n{verification[:200]}...\n")
    
    # Step 3: Final synthesis
    print("Synthesis Agent combining results...")
    final_answer = synthesis_agent(research, verification)
    print(f"Final Answer:\n{final_answer}")
    
    return final_answer

## Run the verified research
result = research_with_verification(
    "What are the health benefits of intermittent fasting?"
)