Das ReAct-Pattern: Thought, Action, Observation

Das ReAct-Pattern (Reasoning and Acting) ist ein Agenten-Entwurfsmuster, bei dem ein LLM abwechselnd schlussfolgert (Thought), ein Werkzeug aufruft (Action) und das Ergebnis zurückliest (Observation). Dieser Loop wiederholt sich, bis der Agent eine finale Antwort ausgibt. Vorgestellt wurde es von Yao et al. (arXiv:2210.03629, Oktober 2022, ICLR 2023). Das Reasoning steuert die Werkzeugwahl, und die Werkzeug-Beobachtungen korrigieren das Reasoning.

• Was es ist: Ein Loop aus Thought, Action und Observation, in dem ein LLM Denken und Handeln verschränkt und Tools im selben Kontext nutzt.
• Wofür es gut ist: Tool-gestützte, faktisch geerdete Aufgaben mit niedriger Latenz und vollständig nachvollziehbarem Verlauf - der Standard-Startpunkt für Agentenprojekte.
• Worauf zu achten ist: Endlos-Loops, Reasoning Drift und halluzinierte Tool-Argumente; abzufangen mit harten Iterations-Limits und Function-Calling.

Woher ReAct kommt und welches Problem es löst

ReAct entstand als Antwort auf zwei gegensätzliche Schwächen früherer Ansätze. Reines Chain-of-Thought (CoT) schlussfolgert ausschließlich intern und halluziniert deshalb Fakten, weil ihm jede Erdung in der Außenwelt fehlt. Reine Action-Agenten - etwa frühe WebGPT- oder SayCan-Ansätze - können umgekehrt nicht abstrakt über langfristige Ziele nachdenken oder sich von Ausnahmen erholen.

ReAct vereint beides: Das verbale Reasoning steht im selben Kontext wie die Aktionen. Dadurch erhält das LLM ein Arbeitsgedächtnis über die gesamte Trajektorie - und der Agent wird interpretierbar. Formal erweitert ReAct den Aktionsraum: Neben externen Aktionen, die echte Beobachtungen auslösen, gibt es sprachliche „Aktionen" (die Thoughts), die nichts in der Umwelt verändern, sondern nur den internen Kontext des Agenten fortschreiben. Bemerkenswert: Das Muster funktioniert bereits mit ein bis zwei In-Context-Beispielen - ohne Fine-Tuning.

Der Loop im Detail: Thought, Action, Observation

Der kanonische Ablauf lautet: User Query → [LLM: Thought] → [LLM: Action] → [Umgebung: Observation] → [LLM: Thought] → … → Finish[Antwort]. Die drei Schritte greifen wie folgt ineinander.

Dieser Zyklus läuft so lange, bis das Modell Action: Finish[Antwort] emittiert. Die praktische Obergrenze liegt meist bei 10-25 Schritten, bevor Kontextverlust oder Reasoning Drift überhandnehmen.

Pseudocode eines ReAct-Loops

```text
context = system_prompt + tool_descriptions + user_query
schritt = 0
MAX_SCHRITTE = 15 # hartes Limit gegen Endlos-Loops

while schritt < MAX_SCHRITTE:
ausgabe = LLM(context) # erzeugt Thought + Action

if ausgabe.action == "Finish":
return ausgabe.action.argument # finale Antwort

observation = fuehre_tool_aus(ausgabe.action) # externer Call
context = context + ausgabe.thought

• • • • • • ausgabe.action
          • observation # Beobachtung anhaengen
            schritt += 1

return "Limit erreicht - keine Loesung gefunden." # sauberer Abbruch
```

Der zentrale Punkt: In jeder Iteration wird der gesamte bisherige Verlauf erneut an das LLM gesendet. Das ist die Quelle sowohl der Stärke (vollständiges Gedächtnis) als auch der wichtigsten Schwäche (Kosten).

Stärken und Grenzen aus der Forschung

Das Originalpapier belegt ReActs Vorteile auf mehreren Benchmarks - wichtig: Die Zahlen stammen aus den Bedingungen von 2022/2023 (GPT-3- und PaLM-Klasse) und sind als Relativwerte, nicht als heutige Absolutwerte zu lesen.

• ALFWorld (textbasierte Haushaltsaufgaben): +34 absolute Prozentpunkte gegenüber Imitation-/RL-Baselines, mit ein bis zwei Beispielen.
• WebShop (E-Commerce-Navigation): +10 absolute Prozentpunkte Erfolgsrate gegenüber IL/IL+RL.
• HotpotQA und Fever: konkurrenzfähig bis besser als reines CoT bzw. reine Aktionsgenerierung; die stärkste Konfiguration ist ein Hybrid, der zwischen internem Wissen und werkzeuggestütztem Reasoning umschaltet.

Auf der Kostenseite ist ReAct teuer und langsam. Der Token-Aufwand wächst mit O(N · T): N Schritte mal kumulierter Kontextlänge - jeder Schritt bezahlt das Präfix (System-Prompt, Tool-Beschreibungen, gesamter Verlauf) erneut. Die Latenz ist strikt sequenziell, also ungefähr N × (LLM-Antwortzeit + Tool-Antwortzeit). Genau diese Präfix-Wiederholung ist die Schwäche, die das Nachfolgemuster ReWOO durch nur zwei LLM-Aufrufe adressiert.

Fehlermodi und Gegenmaßnahmen

Drei Fehlermodi treten in der Praxis besonders häufig auf:

• Endlos-Loops: Ohne harte Schrittbegrenzung kann der Agent endlos im Kreis schlussfolgern. Gegenmaßnahme: explizite Limits - recursion_limit in LangGraph, max_iterations in AutoGen, max_reasoning_attempts in CrewAI. LangGraphs create_react_agent bietet einen remaining_steps-Kanal und bricht mit einer Hinweismeldung ab, wenn weniger als zwei Schritte verbleiben.
• Reasoning Drift / Fehlerfortpflanzung: Hat sich das Modell auf einen falschen Thought festgelegt, interpretiert es nachfolgende Observations so, dass sie dazu passen. Gegenmaßnahme: kürzere Trajektorien, Zwischenvalidierung und - bei verifizierbaren Aufgaben - ein externes Reflexions-/Prüfsignal (Brückenschlag zum Reflexion-Muster).
• Halluzinierte Tool-Argumente und halluzinierte Beobachtungen: Bei mehrdeutigen Werkzeugbeschreibungen erfindet das Modell Argumente; schwächere Modelle „fantasieren" mitunter auch Beobachtungen, statt das echte Tool-Ergebnis abzuwarten. Malformierte JSON-Tool-Argumente sind laut Forschung der häufigste Produktionsfehler auf schwächeren Modellen. Gegenmaßnahme: strukturierte Ausgabe bzw. Function-Calling-Modus nutzen, wann immer der Anbieter ihn unterstützt, und Tool-Beschreibungen präzise formulieren.

Hinzu kommt die bereits genannte Kontext-Aufblähung: Jeder Schritt schickt den vollständigen Verlauf erneut mit.

Konkretes Beispiel: Recherche-Agent für eine Marketing-Agentur

Angenommen, eine Agentur baut einen Agenten, der die aktuelle Mitarbeiterzahl eines Kundenunternehmens recherchiert. Der Loop könnte so verlaufen:

1. Thought: „Ich kenne die aktuelle Zahl nicht und muss sie nachschlagen." → Action: Suche["Mitarbeiterzahl Firma X 2026"] → Observation: Treffer mit Pressemeldung.
2. Thought: „Die Meldung nennt eine Spanne, ich brauche die exakte Zahl." → Action: Oeffne[URL der Pressemeldung] → Observation: Volltext mit „rund 1.200 Beschäftigte".
3. Thought: „Das beantwortet die Frage." → Action: Finish["ca. 1.200 Mitarbeiter, Stand 2026"].

Drei Schritte, drei LLM-Aufrufe, ein vollständig protokollierter Verlauf. Setzt man MAX_SCHRITTE = 15, ist der Agent gegen Endlos-Loops abgesichert - findet er nichts, bricht er sauber ab, statt Tokens zu verbrennen. Genau dieser nachvollziehbare Ablauf ist für Marketing-Teams ohne Entwicklerhintergrund ein realer Vorteil: In n8n etwa zeigt die Ausführungsansicht jeden Thought/Action/Observation-Schritt als auditierbares Log.

Frameworks und Praxis-Empfehlungen (Stand 2026)

ReAct ist in allen gängigen Stacks nativ verfügbar: LangGraph (create_react_agent), CrewAI (jeder Agent ist intern ein ReAct-Agent), AutoGen bzw. das Microsoft Agent Framework (AutoGen ist Stand 2026 im Maintenance-Modus; Microsoft verweist Neuprojekte auf das Agent Framework) und n8n (ReAct AI Agent sowie der neuere, für moderne Function-Calling-Modelle empfohlene Tools Agent). Bei LangChain wandert create_react_agent Stand 2026 von langgraph.prebuilt nach langchain.agents.create_agent mit Middleware-Decorators.

Die wichtigste Praxiserkenntnis stammt von Anthropic („Building Effective Agents", Dezember 2024) und Cognition: Mit dem einfachsten Muster starten - meist ReAct - und erst eskalieren, wenn gemessene Fehlermodi es erzwingen. Moderne Frontier-Modelle beherrschen den Reasoning-Action-Loop nativ über Function-Calling; explizites ReAct-Prompting ist oft unnötig. Entscheidend sind dann Memory, Iterations-Obergrenzen und Tracing. Observability-Werkzeuge (LangSmith, Arize Phoenix, Langfuse) gelten faktisch als Pflicht - für DACH-Compliance (DSGVO, EU AI Act) muss der vollständige Trace persistiert und PII-bereinigt werden.

Für Agenturen und B2B-Entscheider

ReAct ist der pragmatische Einstieg für fast jedes Agentenprojekt: Kundenchatbots mit CRM- und Wissensdatenbank-Anbindung, Support-Triage oder Recherche-Tasks. Es ist günstig zu starten, latenzarm und vollständig auditierbar - drei Eigenschaften, die im DACH-B2B-Umfeld zählen. Setzen Sie von Anfang an harte Iterations-Limits, nutzen Sie Function-Calling statt freitextlicher Argumente und persistieren Sie den Trace für Audit und Debugging. Wenn Sie als Agentur einen Agenten konzipieren oder einen bestehenden Workflow auf Stabilität prüfen lassen möchten, sprechen Sie uns an - wir begleiten Auswahl, Architektur und Compliance-konforme Umsetzung.