Das ReAct Pattern

Wissen

ReAct steht für Reasoning + Acting und ist das fundamentale Pattern hinter fast allen AI Agents. Die Idee ist einfach aber mächtig: Das LLM denkt laut nach, führt eine Aktion aus und beobachtet das Ergebnis -- in einer Schleife, bis die Aufgabe erledigt ist.

Schleife:
  1. THINK  -- Was weiss ich? Was brauche ich noch? Was ist der nächste Schritt?
  2. ACT    -- Tool aufrufen, API abfragen, Code ausführen
  3. OBSERVE -- Ergebnis auswerten, Plan anpassen
  4. Zurück zu 1 (oder fertig)

Think

Der Agent analysiert die Frage und überlegt, welches Tool helfen könnte.

Die ReAct-Schleife im Code

So sieht ein minimaler ReAct-Loop als Pseudocode aus:

def react_agent(task, tools, max_steps=10):
    context = f"Aufgabe: {task}"

    for step in range(max_steps):
        # THINK
        thought = llm.generate(
            f"{context}\n\nDenke nach: Was ist der nächste Schritt?"
        )
        context += f"\nThought: {thought}"

        # Entscheide: Fertig oder weitermachen?
        if "FINAL ANSWER" in thought:
            return extract_answer(thought)

        # ACT
        action = llm.generate(
            f"{context}\n\nWähle ein Tool und formuliere die Aktion."
        )
        context += f"\nAction: {action}"

        # OBSERVE
        result = execute_tool(action, tools)
        context += f"\nObservation: {result}"

    return "Maximale Schritte erreicht."

Verstehen

Warum ReAct funktioniert

Das Geheimnis von ReAct liegt im expliziten Denkschritt. Wenn du ein LLM einfach eine komplexe Aufgabe lösen lässt, springt es oft direkt zur Antwort und macht Fehler. Durch den Zwang, erst zu "denken" (Reasoning), steigt die Qualität drastisch.

Das ist das gleiche Prinzip wie Chain-of-Thought Prompting -- aber in einer Schleife mit echten Aktionen.

iForschungshintergrund

Das ReAct-Paper (Yao et al., 2022) zeigte, dass die Kombination von Reasoning und Acting die Ergebnisse bei komplexen Aufgaben um 20-30% gegenüber reinem Reasoning oder reinem Acting verbessert.

Beispiel: Ein Recherche-Agent

Stell dir vor, du baust einen Agent, der die Frage beantworten soll: "Welches europäische Land hat 2025 die höchste Investition in erneuerbare Energien pro Kopf getätigt?"

Ein einfacher Chatbot würde raten oder veraltete Daten nutzen. Ein ReAct-Agent geht so vor:

Schritt 1: THINK

Ich muss aktuelle Daten zu Investitionen in erneuerbare Energien in Europa finden. Dafür brauche ich eine zuverlässige Quelle. Ich suche zuerst nach aktuellen Berichten von Eurostat oder der IEA.

Schritt 2: ACT

search("renewable energy investment per capita Europe 2025 Eurostat")

Schritt 3: OBSERVE

Die Suche liefert einen Eurostat-Bericht von Q1 2026. Dänemark führt mit 1.840 EUR pro Kopf, gefolgt von Norwegen (1.620 EUR) und Deutschland (980 EUR). Aber Norwegen ist kein EU-Land -- die Frage sagt "europäisch", nicht "EU".

Schritt 4: THINK (neue Iteration)

Norwegen ist geographisch europäisch, auch wenn es nicht in der EU ist. Ich sollte klären, ob die Frage "EU" oder "Europa" meint. Da die Frage "europäisch" sagt, zählt Norwegen. Aber ich sollte die Zahlen mit einer zweiten Quelle verifizieren.

Schritt 5: ACT

search("IEA renewable energy investment Denmark Norway 2025 per capita")

Schritt 6: OBSERVE

IEA bestätigt: Dänemark führt bei EU-Ländern, Norwegen bei allen europäischen Ländern. Die Zahlen stimmen überein.

Finale Antwort

Basierend auf aktuellen Daten von Eurostat und der IEA hat Dänemark (als EU-Land) bzw. Norwegen (als europäisches Land insgesamt) die höchste Pro-Kopf-Investition in erneuerbare Energien 2025 getätigt.

*Beachte die Qualität

Der Agent hat nicht einfach geraten. Er hat recherchiert, eine Ambiguität erkannt ("europäisch" vs. "EU"), eine zweite Quelle herangezogen und eine differenzierte Antwort gegeben. Das ist die Stärke von ReAct.

Warum ist der explizite THINK-Schritt im ReAct Pattern so wichtig?

Vervollständige die drei Schritte des ReAct-Loops:

for step in range(max_steps): # Schritt 1: thought = llm.generate(context + "\nDenke nach:")

# Schritt 2: action = llm.generate(context + "\nWähle ein Tool:") result = execute_tool(action, tools)

# Schritt 3: context += f"\nObservation: {result}"

Anwenden

Wann ReAct einsetzen?

ReAct ist das Standard-Pattern für die meisten Agent-Aufgaben. Nutze es, wenn:

Die Aufgabe mehrere Informationsquellen erfordert
Zwischenergebnisse die nächsten Schritte beeinflussen
Du nicht vorhersagen kannst, wie viele Schritte nötig sind
Fehler erkannt und korrigiert werden müssen

ReAct ist allerdings nicht optimal, wenn:

Die Aufgabe sehr viele parallele Schritte hat (da ReAct sequenziell arbeitet)
Du strenge Kostenkontrolle brauchst (jeder Denkschritt kostet Tokens)
Die Aufgabe komplex genug ist, dass ein separater Planungsschritt sinnvoll wäre (dann schau dir Plan-and-Execute an)

Ein Agent soll 50 Produktseiten gleichzeitig auf Preisänderungen prüfen. Ist ReAct das richtige Pattern?

Reflektieren

ReAct verbindet Reasoning und Acting in einer Schleife: Denken, Handeln, Beobachten. Dieses Pattern ist ideal für Aufgaben, bei denen der nächste Schritt vom Ergebnis des vorherigen abhängt. Für parallele Aufgaben ist es weniger geeignet -- dort helfen andere Patterns wie Fan-Out.