Loop in der Praxis

Im Betrieb lässt du den Agenten nicht auf alles los. Das Produktionsmuster lautet: erst filtern, kurz loopen, dann zurückfallen. Wie das im großen Maßstab aussieht, zeigt Atlan im Engineering-Blog über seinen Bereitschafts-Agenten (Juli 2026).

Ein fest verdrahteter Filter ohne Sprachmodell unterdrückte in einem Zeitraum von 30 Tagen rund 86 % von etwa 11.000 Alarmen, bevor ein einziges TokenTokenDie Einheit, in der Modelle Text lesen und abrechnen: meist ein Wortteil. Anbieter rechnen pro Million Tokens ab.Im Glossar anfiel. Nur rund 1.550 Alarme erreichten den AgentenAgentEin System, in dem ein Sprachmodell seinen nächsten Schritt selbst wählt: Es ruft Werkzeuge auf, wertet das Ergebnis aus und macht weiter, bis das Ziel erreicht ist.Im Glossar. Er denkt bis zu etwa drei Zyklen lang nach. Liegt seine Konfidenz danach noch unter rund 50 %, übernimmt ein fester Workflow in reinem Python. Untersuchungen, die früher über zehn Minuten und ein paar Dollar kosteten, dauern jetzt im Schnitt etwa zwei Minuten und kosten rund 0,28 $.

Die Aufgaben sind klar verteilt. Billiger Code erledigt den häufigen Fall. Das Modell bearbeitet den Rest. Ein fester Pfad fängt alles auf, was das Modell nicht abschließen kann.

Der Bau

Vorweg eine Einordnung. Dieser Bau hat die Form einer Triage: filtern, kurz loopen, zurückfallen. Die zweite Produktionsform ist ein Loop um einen Coding-Agenten, gesteuert von einer Zielprüfung. Sie hat dieselben vier Teile mit anderem Inhalt, und das Handbuch Loop Engineering baut sie auf.

Der ganze Hybrid passt in eine Datei und läuft so, wie er dasteht. Ersetzt du model_next_step durch einen echten API-Aufruf, bleibt die Ablaufsteuerung unverändert.

"""Hybride Alarm-Triage: fester Filter, begrenzter Loop, fester Fallback."""

MAX_TURNS = 3          # Atlan lässt etwa drei Denkzyklen laufen, dann eskaliert es
BUDGET_USD = 0.10      # Ausgabenlimit pro Alarm
COST_PER_TURN = 0.02   # durch echte Werte aus den API-Antworten ersetzen

ALERTS = [
    {"id": 1, "source": "cron", "message": "nightly backup finished OK"},
    {"id": 2, "source": "api", "message": "TimeoutError in /sync after 30s"},
    {"id": 3, "source": "api", "message": "intermittent 502 from payments"},
]

def prefilter(alert):
    """Fest verdrahtet, kostet nichts. Gibt ein Urteil zurück oder None für den Loop."""
    message = alert["message"].lower()
    if alert["source"] == "cron" or "finished ok" in message:
        return {"cause": "bekanntes harmloses Muster", "next_step": "schließen", "via": "filter"}
    return None

def checker(diagnosis):
    """Externer Prüfer: Die Diagnose nennt eine Ursache und einen konkreten nächsten Schritt."""
    return bool(diagnosis.get("cause")) and bool(diagnosis.get("next_step"))

def model_next_step(alert, history):
    """Platzhalter für den Modellaufruf. Hier kommt ein echter API-Aufruf hin."""
    if "timeout" in alert["message"].lower():
        return {"cause": "Client-Timeout bei /sync", "next_step": "Limit auf 60 s erhöhen"}
    return {"cause": "", "next_step": ""}   # diesen Fall löst der Platzhalter nicht

def fallback_workflow(alert):
    """Fester Pfad ohne Modell: liefert immer eine vertretbare Antwort."""
    return {"cause": "vom Agenten nicht geklärt", "next_step": "Rufbereitschaft mit dem Roh-Alarm alarmieren",
            "via": "fallback"}

def triage(alert):
    verdict = prefilter(alert)
    if verdict is not None:
        return verdict                                   # die meisten Alarme enden hier
    history, spent = [], 0.0
    for turn in range(MAX_TURNS):
        diagnosis = model_next_step(alert, history)
        history.append(diagnosis)
        spent += COST_PER_TURN
        if checker(diagnosis):
            diagnosis["via"] = "loop, Runde %d" % (turn + 1)
            return diagnosis                             # Ausgang 1: Prüfer bestanden
        if len(history) >= 2 and history[-1] == history[-2]:
            break                                        # Ausgang 2: dreht sich im Kreis
        if spent > BUDGET_USD:
            break                                        # Ausgang 3: über dem Budget
    return fallback_workflow(alert)                      # jeder andere Ausgang landet hier

if __name__ == "__main__":
    for alert in ALERTS:
        print(alert["id"], triage(alert))

Alarm 1 erreicht das Modell nie. Alarm 2 schließt der Loop in der ersten Runde ab. Alarm 3 dreht sich zweimal im Kreis und landet im Fallback-WorkflowFallback-Workflow · engl. fallback workflowEin fester Pfad ohne Modell, der übernimmt, wenn ein Loop ohne bestandene Prüfung endet. Er liefert immer eine vertretbare Antwort.Im Glossar. Jeder Pfad liefert dieselbe Form zurück, deshalb merkt der Aufrufer nicht, welche Schicht geantwortet hat.

Tipps

• Lass den Filter wachsen. Der Loop bleibt klein. Jede Diagnose, die der Loop zweimal liefert, ist ein Kandidat für eine neue Regel in prefilter.
• Logge via bei jedem Ergebnis. Das Verhältnis von Filter, Loop und Fallback ist deine Kennzahl für die Gesundheit des Systems. Steigt der Anteil des Fallbacks, versagt der Loop im Stillen.
• Halte den Fallback langweilig. Seine Aufgabe ist eine vertretbare Antwort ohne Modell. Für einen zweiten cleveren Versuch ist er der falsche Ort.
• Mach den Prüfer strenger, als es sich höflich anfühlt. Er ist der einzige Teil, an dem sich das Modell nicht vorbeireden kann. Wie du ihn gegen einen echten Coding-Agenten härtest und welche weiteren Bremsen es gibt, zeigt das Handbuch Loop Engineering.

Probier es selbst aus

Drei Experimente zeigen dir, dass jeder Ausgang wirklich trägt. Kopier die Datei aus dem Walkthrough oben und arbeite die Liste ab.

Welche Entscheidungen überhaupt ein Modell verdienen, ist das Thema des nächsten Moduls, Das Gate.

Prüf dich selbst