The False Dichotomy

Trigger → Rules → Actions → Output

Observation → Reasoning → Decision → Action → Learning

if "billing" in subject.lower():
    route_to("billing_team")
elif "technical" in subject.lower():
    route_to("technical_team")
elif "refund" in subject.lower():
    route_to("billing_team", priority="high")
else:
    route_to("general_support")

def route_ticket(ticket):
    # Understands context, sentiment, urgency
    analysis = llm.analyze(ticket.content)
    
    # Handles ambiguous cases
    if analysis.urgency == "critical":
        escalate_to_human(ticket, context=analysis)
    
    # Routes based on understanding, not keywords
    route_to(analysis.team, priority=analysis.priority)
    
    # Can draft response if confidence is high
    if analysis.confidence > 0.8:
        draft_response = llm.generate_response(ticket, analysis)
        send_response(ticket, draft_response)

# Regex patterns for known invoice formats
patterns = {
    "total": r"Total:\s*\$?([\d,]+\.?\d*)",
    "date": r"Date:\s*(\d{2}/\d{2}/\d{4})",
    "vendor": r"From:\s*(.+)"
}

def extract_fields(invoice_text):
    return {field: re.search(pattern, invoice_text).group(1) 
            for field, pattern in patterns.items()}

def extract_invoice_data(invoice_text, invoice_image=None):
    # Handles any format, even handwritten
    prompt = f"""
    Extract the following fields from this invoice:
    - Total amount
    - Date
    - Vendor name
    - Line items
    
    Invoice text: {invoice_text}
    """
    
    if invoice_image:
        return llm.analyze_image(invoice_image, prompt)
    return llm.analyze(prompt)

def personalize_email(template, contact):
    return template.replace("{{first_name}}", contact.first_name) \
                   .replace("{{company}}", contact.company) \
                   .replace("{{industry}}", contact.industry)

def generate_personalized_email(contact, campaign_goal):
    # Understands the contact's context
    research = research_contact(contact)
    
    # Generates unique, relevant content
    return llm.generate(f"""
    Write a personalized outreach email to {contact.name} at {contact.company}.
    
    Context: {research}
    Goal: {campaign_goal}
    
    Requirements:
    - Reference specific company news or achievements
    - Connect our solution to their specific challenges
    - Keep under 150 words
    """)

def check_reorder(inventory):
    for item in inventory:
        if item.quantity <= item.reorder_point:
            create_purchase_order(
                item=item,
                quantity=item.reorder_quantity,
                supplier=item.preferred_supplier
            )

def optimize_inventory(inventory, market_data):
    for item in inventory:
        # Considers multiple factors
        analysis = llm.analyze(f"""
        Current stock: {item.quantity}
        Historical demand: {item.demand_history}
        Supplier lead times: {item.supplier_lead_times}
        Market trends: {market_data[item.category]}
        Upcoming promotions: {get_upcoming_promotions()}
        """)
        
        # Makes nuanced decision
        if analysis.recommend_reorder:
            create_purchase_order(
                item=item,
                quantity=analysis.optimal_quantity,
                supplier=analysis.recommended_supplier,
                timing=analysis.optimal_timing
            )

Incoming Request
    ↓
[Traditional Router] → Quick classification (1ms)
    ↓
   ├─ Simple → [Traditional Workflow] → Auto-resolve
   └─ Complex → [AI Agent] → Reason and resolve

Document Received
    ↓
[AI Agent] → Extract and validate fields (2s)
    ↓
[Traditional Workflow] → Process based on extracted data (100ms)

Decision Required
    ↓
[AI Agent] → Analyze options and recommend (3s)
    ↓
[Traditional Workflow] → Execute approved action (200ms)

Email/Webhook Trigger
    ↓
[Traditional] Parse email structure (50ms)
    ↓
[Traditional] Check sender against known patterns (20ms)
    ↓
[AI Agent] Analyze content and intent (2s)
    ↓
[AI Agent] Generate response draft (3s)
    ↓
[Traditional] Route to appropriate queue (50ms)
    ↓
[Traditional] Log to database (30ms)