Start/Vertiefung/Methoden/Reflection und Self-Revision Pattern für LLM-Agenten
11. April 2026

Ein Modell gibt eine Antwort aus, liest sie noch einmal, schreibt eine Kritik und generiert daraus eine zweite, bessere Version. Dieses Muster -- Reflection oder Self-Revision -- ist der Grund, warum moderne Coding-Agenten wie Claude Code oder Cursor Tests laufen lassen, den Fehler lesen und es erneut probieren. Und es ist der Grund, warum ein kleineres Modell mit mehr Rechenzeit pro Aufgabe die Qualität eines viel größeren Modells erreichen kann.

Intuition

Der Gedanke ist so alt wie die wissenschaftliche Methode: Hypothese aufstellen, Ergebnis prüfen, Hypothese revidieren. Oder aus der Schule: Der Schüler rechnet eine Aufgabe, macht die Probe, merkt, dass es nicht aufgeht, und korrigiert sich. Niemand erwartet, dass ein anspruchsvolles Problem beim ersten Versuch gelöst wird. Bei Sprachmodellen war das erstaunlich lange die Default-Erwartung -- eine Frage stellen, eine Antwort bekommen, fertig.

Reflection bricht mit dieser Einschritt-Logik. Der Output ist kein Endprodukt mehr, sondern ein Zwischenstand, auf den das Modell selbst reagiert. Die zentrale Einsicht: Ein Modell, das einen Fehler erkennt, wenn man ihn ihm zeigt, kann diesen Fehler oft auch finden, wenn man es explizit fragt "Prüfe deine Antwort". Das Modell wird vom Autor zum Gutachter seines eigenen Textes. Solange beides in einem Schritt passiert, zieht das Modell eine plausible Fortsetzung aus seiner Trainingsverteilung und bleibt dabei.

Technische Details

Der generische Loop

Alle Reflection-Verfahren lassen sich auf denselben Vier-Schritte-Loop reduzieren:

  1. Generate -- Das Modell erzeugt eine erste Antwort auf den Prompt.
  2. Evaluate -- Die Antwort wird bewertet. Von einem Kritiker-Prompt, einem externen Verifier, einem Unit-Test, einem Compiler, einem Judge-Modell oder einer Kombination.
  3. Reflect -- Das Modell liest die Bewertung und formuliert in natürlicher Sprache, was schief lief und wie es besser geht.
  4. Regenerate -- Das Modell produziert mit Original-Prompt, alter Antwort und Reflexion eine neue Antwort.

Der Loop wiederholt sich, bis ein Abbruchkriterium erreicht ist -- bestanden, maximale Iterationen, keine Verbesserung mehr.

def reflect_loop(task, max_iters=5):
    history = []
    output = llm.generate(prompt=task)
    for _ in range(max_iters):
        score, feedback = evaluate(task, output)
        if score.passed:
            return output
        reflection = llm.generate(
            prompt=f"Task: {task}\nOutput: {output}\n"
                   f"Feedback: {feedback}\n"
                   f"What went wrong and how to fix it?"
        )
        history.append((output, reflection))
        output = llm.generate(
            prompt=f"Task: {task}\nPrevious attempts: {history}\n"
                   f"Write an improved answer."
        )
    return output

Drei Schulen der Evaluation

Der Evaluate-Schritt ist der neuralgische Punkt. Davon hängt ab, ob die Schleife tatsächlich konvergiert oder nur hin und her pendelt. Es gibt drei gängige Varianten:

Self-Critique -- Das Modell bewertet sich selbst mit einem Kritiker-Prompt. Kein externer Aufwand, aber grundlegendes Problem: Ein Fehler, der beim Generieren übersehen wurde, wird oft auch beim Prüfen übersehen. Self-Refine (Madaan et al., 2023) erzielt auf sieben Aufgaben im Schnitt etwa 20 Prozentpunkte Verbesserung gegenüber One-Shot. Huang et al. (2023, "Large Language Models Cannot Self-Correct Reasoning Yet") zeigen dagegen, dass reines Self-Critique bei Reasoning-Aufgaben häufig schlechter wird -- das Modell revidiert korrekte Antworten in falsche.

External Verifier -- Die Bewertung kommt von einem deterministischen System: Unit-Tests, Type-Checker, Compiler, Linter, Suchmaschine, Datenbank-Query. Das ist das Regime, in dem Reflection zuverlässig funktioniert, weil der Verifier nicht dieselben Fehler macht wie der Generator. Reflexion (Shinn et al., NeurIPS 2023) hat so 91% pass@1 auf HumanEval erreicht, gegenüber 80% für GPT-4 als One-Shot-Baseline.

Judge-Modell -- Ein separates (oft stärkeres) LLM bewertet die Antwort. Grundlage von Anthropics Constitutional AI, wo ein Modell seine Outputs gegen eine explizite Verfassung prüft und Revisionen verfasst. Die revidierten Paare dienen als Präferenzdaten für RL from AI Feedback (RLAIF). Constitutional AI ist damit kein Test-Time-Reflection, sondern verwendet das Pattern als Trainings-Signal.

Abbruch und Konvergenz

Naive Loops laufen entweder zu wenig oder zu viel (Overcorrection auf bereits gute Antworten). Praktische Heuristiken:

Der Konvergenz-Verlauf ist selten monoton. Typisches Muster bei komplexen Aufgaben: 60% -> 72% -> 75% -> 74% -> 75%. Die ersten ein bis zwei Reflektionen bringen den größten Gewinn, danach Plateau oder Rauschen.

Abgrenzung zu Chain-of-Thought

Reflection wird oft mit Chain-of-Thought (CoT) verwechselt, ist aber strukturell verschieden. CoT ist ein einzelner Forward Pass, der Zwischenschritte vor der finalen Antwort generiert -- alles in einer Generierung, ohne die Möglichkeit, den Zwischenschritt zu verwerfen. Reflection ist multi-turn: Die erste Antwort wird vollständig produziert und dann zur Eingabe eines zweiten Forward Pass, der sie bewerten oder revidieren kann.

Beide Verfahren sind komplementär und werden in der Praxis kombiniert. ReAct (Yao et al., 2022) hat Reasoning und Acting innerhalb eines Loops verschränkt. Reflexion erweitert das um einen Memory-Buffer: Jede fehlgeschlagene Episode hinterlässt einen verbalen Hinweis, auf den das Modell in der nächsten Episode zugreift -- verbal reinforcement learning ohne Gewichts-Updates.

Praxis-Relevanz

Reflection ist heute an vielen Stellen eingebaut, ohne dass es so genannt wird. Wer Claude Code zusieht, wie es nach einem fehlgeschlagenen Build den Output liest, den Fehler benennt und den Patch anpasst, sieht einen External-Verifier-Loop mit dem Compiler als Verifier. Cursor und Aider nutzen Test-Ergebnisse analog. Bei autonomen Agenten wie Devin oder OpenHands ist Reflection der Mechanismus, der verhindert, dass eine einmal falsch gewählte Richtung den ganzen Lauf versenkt.

Der wichtigste Punkt ist der Compute-Tradeoff. Snell et al. (Google DeepMind, 2024) haben gezeigt, dass ein kleineres Basis-Modell mit intelligent verteilter Test-Time-Compute ein 14-mal größeres Modell bei FLOP-gleicher Auslastung schlagen kann -- auf Aufgaben, bei denen das kleine Modell nicht trivial versagt. Praktisch: Wenn die Aufgabe sich verifizieren lässt, ist es oft günstiger, ein mittelgroßes Modell drei- bis fünfmal iterieren zu lassen als einmal ein Flagship-Modell zu befragen.

Die Grenze bleibt die Verifier-Qualität. Ohne externes Signal ist Reflection unzuverlässig -- der Huang-Befund hat Bestand. SCoRe (Kumar et al., DeepMind 2024) löst das, indem es Modelle per Multi-Turn-RL direkt darauf trainiert, sich selbst zu korrigieren, statt sich auf Prompting zu verlassen. Auf MATH hat SCoRe die Self-Correction-Fähigkeit von Gemini 1.5 Flash um 9,1 Prozentpunkte gehoben. Der Trend: Reflection nicht mehr nur als Inference-Pattern, sondern als antrainierte Fähigkeit.

Für das eigene Agent-Building folgen drei Heuristiken. Erstens: Einen Verifier einbauen, bevor man Reflection einbaut -- die Schleife ist nur so gut wie das Signal. Zweitens: Klare Abbruch-Kriterien, insbesondere Regressions-Erkennung, damit korrekte Outputs nicht in falsche revidiert werden. Drittens: Modellgröße zu Iterationen als Parameter behandeln, nicht als Gegebenheit. Ein kleineres Modell mit gutem Reflection-Loop ist oft der bessere Deal, solange es einen Verifier gibt, dem man vertraut.

Quellen

Nach oben