AI Agents · Lektion

Ticket-Routing und Eskalationslogik

Intentionen klassifizieren, an spezialisierte Agenten weiterleiten und Eskalationstrigger festlegen.

Lektion 1 von 413 Schritte

Ticket-Routing und Eskalationslogik ist eine kostenlose AI Agents-Lektion auf CoddyKit. Dies ist Lektion 1 von 4. Du kannst die komplette Lektion unten kostenlos lesen – dann übst du sie direkt im Browser mit einem integrierten Code-Editor und einem KI-Tutor rund um die Uhr. Sie ist Teil des AI Agents-Lernpfads, und dein Fortschritt wird über Web und CoddyKit-App synchronisiert. Der AI Agents-Kurs umfasst insgesamt 4 Lektionen.

Das Routing-Problem

Ein Kundenservice-Agent erhält täglich Tausende unterschiedlicher Nachrichten: Abrechnungsstreitigkeiten, Passwortzurücksetzungen, Produktmängel, Lieferverzögerungen und Funktionswünsche. Wenn jede Nachricht an denselben Handler gesendet wird, entstehen langsame Antworten von geringer Qualität.

Ticket-Routing klassifiziert jede Nachricht und leitet sie an das Team weiter, das am besten für ihre Lösung geeignet ist.

Intent-Klassifizierung mit einem LLM

Die Routing-Schicht ruft ein LLM mit einem Klassifizierungs-Prompt auf. Das Modell gibt eine strukturierte Antwort mit einem intent-Label und einem confidence-Wert zurück.

import openai, json

client = openai.OpenAI(api_key='YOUR_OPENAI_KEY')

INTENTS = ['billing', 'technical_support', 'returns_refunds',
           'account_access', 'shipping', 'general_inquiry']

def classify_intent(message: str) -> dict:
    prompt = (
        f'Classify this customer message into exactly one intent.\n'
        f'Intents: {INTENTS}\n'
        f'Message: "{message}"\n'
        f'Respond with JSON: {{"intent": "...", "confidence": 0.0-1.0}}'
    )
    resp = client.chat.completions.create(
        model='gpt-4o-mini',
        messages=[{'role': 'user', 'content': prompt}],
        response_format={'type': 'json_object'}
    )
    return json.loads(resp.choices[0].message.content)

Weiterleitung an Fachwarteschlangen

Sobald der Intent bekannt ist, leiten Sie das Ticket an die passende Fachwarteschlange weiter. Jede Warteschlange verfügt über eigene Antwortvorlagen, SLAs und Eskalationsregeln.

ROUTING_MAP = {
    'billing':           'queue_billing',
    'technical_support': 'queue_tech',
    'returns_refunds':   'queue_returns',
    'account_access':    'queue_tech',
    'shipping':          'queue_fulfillment',
    'general_inquiry':   'queue_general'
}

def route_ticket(ticket: dict) -> str:
    result = classify_intent(ticket['message'])
    intent = result['intent']
    confidence = result['confidence']
    queue = ROUTING_MAP.get(intent, 'queue_general')
    ticket['intent'] = intent
    ticket['confidence'] = confidence
    ticket['queue'] = queue
    return queue

Konfidenzschwelle für Eskalationen

Wenn der Klassifikator unsicher ist (Konfidenz unter 0,7), kann die automatische Weiterleitung falsch sein. Tickets mit niedriger Konfidenz sollten zur manuellen Triage an einen Menschen eskaliert werden, statt sie automatisch an einen Spezialisten weiterzuleiten.

CONFIDENCE_THRESHOLD = 0.70

def route_with_escalation(ticket: dict) -> dict:
    result = classify_intent(ticket['message'])
    intent = result['intent']
    confidence = result['confidence']

    if confidence < CONFIDENCE_THRESHOLD:
        return {
            'ticket_id': ticket['id'],
            'action': 'escalate_to_human',
            'reason': f'Low confidence: {confidence:.2f}',
            'suggested_intent': intent
        }

    queue = ROUTING_MAP.get(intent, 'queue_general')
    return {
        'ticket_id': ticket['id'],
        'action': 'route_to_queue',
        'queue': queue,
        'intent': intent,
        'confidence': confidence
    }

Prioritätseskalation auf SLA-Basis

Auch automatisch weitergeleitete Tickets können ihr SLA verletzen, wenn sie nicht rechtzeitig gelöst werden. Ein Hintergrundprozess vergleicht das Alter der Tickets mit den SLA-Zielen und eskaliert überfällige Tickets an eine Supervisor-Warteschlange.

from datetime import datetime, timezone

SLA_HOURS = {
    'queue_billing':      4,
    'queue_tech':         8,
    'queue_returns':      24,
    'queue_fulfillment':  12,
    'queue_general':      48
}

def check_sla_breach(ticket: dict) -> bool:
    created = datetime.fromisoformat(ticket['created_at'])
    age_hours = (datetime.now(timezone.utc) - created).total_seconds() / 3600
    sla = SLA_HOURS.get(ticket['queue'], 24)
    if age_hours > sla and ticket['status'] == 'open':
        ticket['queue'] = 'queue_supervisor_escalation'
        ticket['escalation_reason'] = f'SLA breach: {age_hours:.1f}h > {sla}h'
        return True
    return False

if __name__ == '__main__':
    from datetime import datetime, timedelta, timezone
    old_ticket = {
        'created_at': (datetime.now(timezone.utc) - timedelta(hours=10)).isoformat(),
        'queue': 'queue_billing',
        'status': 'open',
    }
    breached = check_sla_breach(old_ticket)
    print(f'SLA breached: {breached}')
    if breached:
        print('Escalation reason:', old_ticket['escalation_reason'])

Routing mit mehreren Labels für komplexe Tickets

Manche Nachrichten betreffen mehrere Bereiche: „Meine Bestellung ist beschädigt angekommen und mir wurde der Betrag zweimal berechnet.“ Ein Klassifikator mit mehreren Labels gibt mehrere Intents zurück; das Ticket wird in beide Warteschlangen dupliziert, und die Agenten stimmen sich bei der Lösung ab.

def classify_multi_intent(message: str) -> list[dict]:
    prompt = (
        f'A customer message may have multiple intents.\n'
        f'Intents: {INTENTS}\n'
        f'Message: "{message}"\n'
        f'Return JSON array: [{{"intent": "...", "confidence": 0.0}}]\n'
        f'Include only intents with confidence > 0.5'
    )
    resp = client.chat.completions.create(
        model='gpt-4o-mini',
        messages=[{'role': 'user', 'content': prompt}],
        response_format={'type': 'json_object'}
    )
    data = json.loads(resp.choices[0].message.content)
    return data.get('intents', [])

# Route to multiple queues
def route_multi(ticket: dict) -> list[str]:
    intents = classify_multi_intent(ticket['message'])
    return [ROUTING_MAP.get(i['intent'], 'queue_general') for i in intents]

Ticket-Metadaten extrahieren

Extrahieren Sie vor dem Routing Metadaten aus der Nachricht, um die Spezialisten zu unterstützen: Bestellnummern, Produktnamen und Konto-IDs. Dadurch wird die Lösung beschleunigt, weil die erste Runde von Rückfragen entfällt.

def extract_metadata(message: str) -> dict:
    prompt = (
        f'Extract structured metadata from this customer message.\n'
        f'Return JSON: {{"order_id": null, "product": null, "account_email": null}}\n'
        f'Use null for fields not mentioned.\n'
        f'Message: "{message}"'
    )
    resp = client.chat.completions.create(
        model='gpt-4o-mini',
        messages=[{'role': 'user', 'content': prompt}],
        response_format={'type': 'json_object'}
    )
    return json.loads(resp.choices[0].message.content)

meta = extract_metadata('My order #A12345 for the blue headphones never arrived.')
print(meta)  # {'order_id': 'A12345', 'product': 'blue headphones', 'account_email': None}

Stimmungsbasierte Prioritätserhöhung

Verärgerte Kunden kündigen mit höherer Wahrscheinlichkeit. Erkennen Sie negative Stimmung und erhöhen Sie die Ticketpriorität, damit unzufriedene Kunden schneller Antworten erhalten, auch wenn ihr SLA noch nicht abgelaufen ist.

def detect_sentiment(message: str) -> str:
    prompt = f'Classify sentiment as positive/neutral/negative.\nMessage: "{message}"\nReturn JSON: {{"sentiment": "..."}}'
    resp = client.chat.completions.create(
        model='gpt-4o-mini',
        messages=[{'role': 'user', 'content': prompt}],
        response_format={'type': 'json_object'}
    )
    return json.loads(resp.choices[0].message.content)['sentiment']

def set_priority(ticket: dict) -> str:
    sentiment = detect_sentiment(ticket['message'])
    if sentiment == 'negative':
        ticket['priority'] = 'high'
    elif sentiment == 'positive':
        ticket['priority'] = 'low'
    else:
        ticket['priority'] = 'normal'
    return ticket['priority']

Eskalationskette definieren

Definieren Sie eine klare Eskalationskette, damit jede Warteschlange eine Ausweichstufe hat. Wenn die Warteschlange für den First-Level-Support ein Ticket nicht innerhalb des SLA lösen kann, wird es zunächst an Tier 2, dann an Tier 3 (Senior-Spezialist) und anschließend an den Supervisor weitergeleitet.

ESCALATION_CHAIN = {
    'queue_tech':              'queue_tech_tier2',
    'queue_tech_tier2':        'queue_tech_senior',
    'queue_tech_senior':       'queue_supervisor_escalation',
    'queue_billing':           'queue_billing_senior',
    'queue_billing_senior':    'queue_supervisor_escalation',
    'queue_returns':           'queue_supervisor_escalation',
    'queue_fulfillment':       'queue_supervisor_escalation',
    'queue_general':           'queue_supervisor_escalation',
    'queue_supervisor_escalation': None  # terminal — human manager
}

def escalate(ticket: dict) -> str | None:
    next_queue = ESCALATION_CHAIN.get(ticket['queue'])
    if next_queue:
        ticket['queue'] = next_queue
    return next_queue

if __name__ == '__main__':
    ticket = {'queue': 'queue_tech'}
    for _ in range(3):
        nxt = escalate(ticket)
        print(f"Escalated to: {ticket['queue']}")
        if nxt is None:
            break

Die vollständige Routing-Pipeline

Kombinieren Sie Klassifizierung, Metadatenextraktion, Stimmungsanalyse und SLA-Prüfung zu einer einzigen Pipeline, die für jedes eingehende Ticket ausgeführt wird.

def process_ticket(raw_ticket: dict) -> dict:
    ticket = dict(raw_ticket)

    # Step 1: Classify and route
    routing = route_with_escalation(ticket)
    ticket.update(routing)

    # Step 2: Extract metadata
    ticket['metadata'] = extract_metadata(ticket['message'])

    # Step 3: Set priority from sentiment
    ticket['priority'] = set_priority(ticket)

    # Step 4: Check if already breaching SLA
    if ticket.get('created_at'):
        check_sla_breach(ticket)

    return ticket

result = process_ticket({
    'id': 'T001',
    'message': 'I was charged twice for my subscription last month!',
    'created_at': '2026-05-28T10:00:00+00:00',
    'status': 'open'
})
print(result)

Routing-Genauigkeit überwachen

Überwachen Sie die Routing-Genauigkeit, indem Sie einen Prozentsatz der automatisch weitergeleiteten Tickets für eine manuelle Prüfung auswählen. Wenn ein Spezialist ein Ticket einer anderen Warteschlange zuweist, handelt es sich um einen Routing-Fehler. Nutzen Sie die Fehler, um den Prompt zu verbessern oder einen Klassifikator feinzujustieren.

import random

def log_routing_decision(ticket: dict, final_queue: str):
    was_correct = ticket.get('queue') == final_queue
    if not was_correct:
        print(f'[ROUTING_ERROR] ticket={ticket["id"]} '
              f'predicted={ticket["queue"]} actual={final_queue} '
              f'confidence={ticket.get("confidence", 0):.2f}')

# Specialist reassigns ticket: log the discrepancy
def specialist_reassign(ticket: dict, new_queue: str):
    log_routing_decision(ticket, new_queue)
    ticket['queue'] = new_queue
    return ticket

if __name__ == '__main__':
    ticket = {'id': 'T-1001', 'queue': 'queue_billing', 'confidence': 0.62}
    specialist_reassign(ticket, 'queue_tech')

Welche Konfidenzschwelle sollte eine Eskalation an einen Menschen statt einer automatischen Weiterleitung auslösen?

Die Wahl der richtigen Konfidenzschwelle stellt ein Gleichgewicht zwischen Automatisierungsrate und Routing-Genauigkeit her. Eine zu hohe Schwelle führt zu übermäßig vielen Eskalationen, eine zu niedrige zu Fehlleitungen.

Beantworte es in der interaktiven Lektion

Zusammenfassung des Ticket-Routings

Effektives Ticket-Routing kombiniert die Intent-Klassifizierung durch ein LLM mit einer Konfidenzschwelle für die Eskalation an einen Menschen, der Metadatenextraktion für eine schnellere Lösung, einer stimmungsbasierten Priorisierung gefährdeter Kunden und einer SLA-Eskalationskette, damit kein Ticket verloren geht.

Kostenlos starten

Lerne AI Agents mit einem KI-Tutor — kostenlos

Schreibe und führe echten Code in deinem Browser aus, bekomme sofortige Hilfe von einem 24/7 KI-Tutor und setze dein Lernen im Web oder in der App fort.

Kurse: 60
Lektionen: 239

Kostenlos lernen Den vollständigen Kurs ansehen

Häufig gestellte Fragen

Ist die Lektion „Ticket-Routing und Eskalationslogik“ kostenlos?

Ja — der vollständige Text von „Ticket-Routing und Eskalationslogik“ ist hier im Web kostenlos zu lesen. Um sie interaktiv zu üben (integrierter Code-Editor und 24/7 KI-Tutor) und den Rest des AI Agents-Kurses freizuschalten, upgrade auf CoddyKit PRO. Der AI Agents-Kurs umfasst insgesamt 4 Lektionen.

Was lerne ich in „Ticket-Routing und Eskalationslogik“?

Intentionen klassifizieren, an spezialisierte Agenten weiterleiten und Eskalationstrigger festlegen. Du übst AI Agents mit praktischem Code, den du direkt im Browser ausführst, und ein 24/7 KI-Tutor beantwortet deine Fragen während du die Lektion bearbeitest.

Brauche ich Erfahrung, um AI Agents zu starten?

Keine Vorkenntnisse erforderlich. AI Agents auf CoddyKit ist für Anfänger bis fortgeschrittene Lernende strukturiert, sodass du hier starten oder von Anfang an beginnen und in deinem eigenen Tempo voranschreiten kannst. Dies ist Lektion 1 von 4.

Wie lange dauert die Lektion „Ticket-Routing und Eskalationslogik“?

Die meisten CoddyKit-Lektionen dauern etwa 5–10 Minuten. Jede ist kompakt und interaktiv, sodass du stetig Fortschritte machst und genau dort weitermachst, wo du aufgehört hast – im Web und in der App.

Kann ich in dieser AI Agents-Lektion Code schreiben und ausführen?

Ja. Jede AI Agents-Lektion enthält einen integrierten Code-Editor, sodass du echten Code direkt in deinem Browser schreibst und ausführst und sofort KI-Feedback erhältst — ohne lokale Einrichtung erforderlich.

Alle Lektionen in diesem Kurs

← Zurück zu AI Agents