AI Customer Support: Lessons from Production

hybrid_model:
  ai_handles:
    - Common questions (FAQ-style)
    - Information lookup
    - Ticket categorization
    - Initial response drafting
    - Off-hours coverage

  humans_handle:
    - Complex issues
    - Emotional situations
    - Escalations
    - Policy exceptions
    - High-value customers

  handoff:
    - Seamless transition
    - Full context transfer
    - No repeat information

class SupportAssistant:
    """RAG-powered support assistant."""

    async def respond(
        self,
        message: str,
        conversation: list[Message],
        customer_context: CustomerContext
    ) -> SupportResponse:
        # Retrieve relevant documentation
        docs = await self.retriever.search(
            query=message,
            filters={"product": customer_context.product}
        )

        # Retrieve similar past tickets
        similar_tickets = await self.ticket_search.find_similar(
            message,
            resolved_only=True
        )

        # Generate response
        response = await self.llm.generate(
            system=self._build_system_prompt(customer_context),
            messages=[
                *conversation,
                self._inject_context(docs, similar_tickets),
                {"role": "user", "content": message}
            ]
        )

        # Determine if escalation needed
        should_escalate = await self._check_escalation(
            message, response, customer_context
        )

        return SupportResponse(
            content=response,
            sources=docs,
            escalate=should_escalate
        )

    async def _check_escalation(
        self,
        message: str,
        response: str,
        context: CustomerContext
    ) -> bool:
        escalation_signals = [
            "frustrated" in message.lower(),
            "cancel" in message.lower(),
            context.is_high_value,
            await self._low_confidence(response),
            await self._complex_issue(message)
        ]

        return sum(escalation_signals) >= 2

escalation_failure:
  symptom: "Users trapped in AI loop"
  impact: "Extreme frustration, churn"
  solution:
    - Clear "talk to human" option
    - Auto-escalate on frustration signals
    - Time-based escalation
    - Never make humans unreachable

overconfidence_failure:
  symptom: "AI gives wrong answers confidently"
  impact: "Worse than no answer"
  solution:
    - Include uncertainty signals
    - Source citations
    - "I'm not sure" is acceptable
    - Fact-check critical information

context_failure:
  symptom: "AI asks questions already answered"
  impact: "Feels robotic, wastes time"
  solution:
    - Full conversation history
    - Customer account context
    - Previous ticket history
    - Don't repeat questions

support_ai_metrics:
  containment:
    definition: "Issues resolved without human"
    target: "60-80% for common issues"
    trap: "Don't optimize this at expense of satisfaction"

  resolution_time:
    definition: "Time to resolution"
    target: "50%+ reduction vs human-only"
    measure: "Both AI and escalated cases"

  csat:
    definition: "Customer satisfaction"
    target: "Match or exceed human-only"
    measure: "Post-interaction surveys"

  escalation_quality:
    definition: "Human-handled after AI proportion"
    target: "20-40%"
    trap: "Too low means blocking users, too high means AI not helping"

support_ai_implementation:
  start_small:
    - One product or category
    - Internal testing first
    - Gradual customer rollout

  feedback_loop:
    - Track what's escalated
    - Analyze failed conversations
    - Continuously improve content
    - Regular human review

  guardrails:
    - Don't make promises AI can't keep
    - Clear limitations communication
    - Always allow human escalation