ReAct-Prompting: Schleife aus Denken und Handeln

ReAct-Prompting ist ein Muster, bei dem ein Sprachmodell zwischen Denken und Handeln wechselt: Es schreibt einen Gedanken dazu, was zu tun ist, führt eine Aktion wie eine Suche oder einen Tool-Aufruf aus, liest das Ergebnis und entscheidet erst dann über den nächsten Schritt. Der Name steht für Reason + Act und stammt von Yao et al. 2022, "ReAct: Synergizing Reasoning and Acting in Language Models". Mit React, der JavaScript-Bibliothek für Benutzeroberflächen, hat es nichts zu tun.

Die meisten KI-Agenten, die im Web surfen, Code ausführen oder Dateien bearbeiten, laufen in irgendeiner Version dieser Schleife. Wenn du sie einmal von Hand durchgegangen bist, lässt sich das Verhalten von Agenten viel leichter vorhersagen und debuggen.

Die Schleife aus Thought, Action und Observation

Ein ReAct-Prompt bittet das Modell, drei Arten von Zeilen zu schreiben. Die Labels bleiben in den Beispielen unten auf Englisch, weil der Python-Code weiter unten genau nach Action: sucht.

• Thought: eine Überlegung zur aktuellen Lage und dazu, welche Information fehlt.
• Action: ein Tool-Aufruf in einem festen Format, etwa search[query], read_file[path] oder finish[answer].
• Observation: das Ergebnis dieser Aktion. Diese Zeile schreibt nicht das Modell. Dein Programm (oder du) führt die Aktion aus und fügt die echte Ausgabe ins Protokoll ein.

Dann geht das ganze Protokoll zurück an das Modell, das den nächsten Thought schreibt. Die Schleife endet, wenn das Modell die Abschlussaktion wählt. Das Modell führt nie selbst ein Tool aus; es fragt nur, und der Code drumherum entscheidet, ob die Anfrage ausgeführt wird.

Warum Denken plus Handeln beides allein schlägt

Das Paper verglich ReAct mit Prompts, die nur denken (Chain of Thought), und Prompts, die nur handeln (Tool-Aufrufe ohne ausgeschriebene Überlegung). Bei Fragebeantwortung und Faktenprüfung mit einem Wikipedia-Suchtool baute reines Denken oft ein überzeugtes Argument auf einem Fakt auf, den das Modell erfunden hatte, während ReAct den Fakt nachschlagen konnte; die besten Ergebnisse bei der Fragebeantwortung kamen aus der Kombination von ReAct und Chain of Thought, wobei auf das jeweils andere zurückgegriffen wurde, wenn das erste keine sichere Antwort lieferte. Reines Handeln tat sich schwer damit, das Ziel zu zerlegen und das Gefundene zu einer Antwort zusammenzuführen; die ausgeschriebenen Gedanken hielten den Plan sichtbar. Bei zwei interaktiven Aufgaben, einem textbasierten Haushaltsspiel und einem simulierten Online-Shop, schnitt ReAct mit ein oder zwei Beispielen im Prompt besser ab als die trainierten Vergleichssysteme der Autoren.

Die allgemeine Lehre: Chain of Thought hilft einem Modell beim Planen, Tools geben ihm Fakten, und keins von beidem reicht für eine Aufgabe, die beides braucht.

Ein ReAct-Agent, Zug um Zug

Der Block unten ist ein kleiner Programmier-Agent mit zwei Tools. Jeder Tab ist dasselbe Gespräch einen Schritt später: Die Observation-Zeilen sind das, was das Programm nach dem Ausführen der vorigen Aktion zurück eingefügt hat. Lies die Antworten der Reihe nach.

Zug 1Zug 2Zug 3

EditCopy

System prompt

Löse die Aufgabe, indem du Thought, Action und Observation wiederholst. Behalte diese drei Labels auf Englisch bei. Thought: Überleg, was du weißt und was als Nächstes zu tun ist. Action: genau eine dieser Aktionen run_tests[path] führt pytest für eine Datei aus und gibt die Ausgabe zurück read_file[path] gibt den Inhalt einer Datei zurück finish[answer] beendet die Aufgabe mit deiner Antwort Schreib einen Thought und eine Action, dann hör auf. Die Observation bekommst du geliefert.

Aufgabe: tests/test_cart.py schlägt seit dem Merge von gestern fehl. Finde die Ursache.

Try it

Chat apps receive the system prompt as the start of your message, so this tries its wording, not its priority. To test it as standing instructions, put it in the app's custom instructions or the API's system field.

Example replyReplies vary between models and runs.

Thought: Ich weiß nicht, welcher Test fehlschlägt und wie. Wenn ich die Tests ausführe, sehe ich die genaue Assertion, bevor ich Code lese. Action: run_tests[tests/test_cart.py]

Achte auf zwei Dinge. Die erste Aktion ist ein Testlauf, keine Vermutung: Das Modell hat Belege gesammelt, bevor es Code liest. Und jeder Gedanke bezieht sich auf die letzte Beobachtung, und genau das kann Chain of Thought nicht.

ReAct in einer Chat-App ausprobieren

Um die Schleife zu sehen, brauchst du keinen Code. In ChatGPT, Claude oder Gemini kannst du selbst das Tool sein: Das Modell fordert eine Aktion an, du führst sie aus und fügst das Ergebnis ein.

Sei die Tools des Modells

EditCopy

Fill inFrage

Ich will diese Frage beantworten: Warum läuft der Lüfter meines Laptops laut, auch wenn ich gar nichts mache? Hilf mir, indem du in einer Schleife arbeitest. Jede Antwort enthält genau einen Gedanken (was du bisher weißt und was fehlt) und eine Aktion: etwas Konkretes, das ich prüfen, ausführen oder nachschlagen soll, mit den genauen Schritten. Dann hör auf und warte. Ich antworte mit dem Ergebnis als "Beobachtung: ...". Wenn du genug Belege hast, antworte mit "Antwort:" und deiner Schlussfolgerung. Rate keine Antwort, bevor du Belege hast.

Try it

Example replyReplies vary between models and runs.

Gedanke: Ein lauter Lüfter im Leerlauf bedeutet meist, dass im Hintergrund etwas die CPU auslastet oder dass der Lüfter Mühe beim Kühlen hat (Staub, verdeckte Lüftungsschlitze). Wenn wir zuerst die CPU-Auslastung prüfen, lassen sich diese beiden Fälle trennen.

Aktion: Öffne den Task-Manager (Strg+Umschalt+Esc unter Windows) oder die Aktivitätsanzeige (Programme > Dienstprogramme auf dem Mac). Sortiere die Prozesse nach CPU, warte 30 Sekunden und nenn mir die drei obersten Prozesse mit ihren CPU-Prozenten.

Dieselben Anweisungen, mit einer echten Funktion hinter jeder Aktion, ergeben einen Agenten.

Eine minimale ReAct-Schleife in Python

Im Code schickt das Programm das Protokoll, findet die Action-Zeile in der Antwort, führt die passende Funktion aus, hängt die Observation an und wiederholt das. Diese Skizze nutzt das OpenAI Python SDK und den System-Prompt des Programmier-Agenten oben.

import re
import subprocess
from pathlib import Path
from openai import OpenAI

client = OpenAI()
MODEL = "your-model-id"  # e.g. from your provider's model list
PROJECT = Path.cwd().resolve()
READABLE = {".py", ".md", ".txt", ".toml", ".cfg"}

def inside_project(arg):
    # The model chooses arg: resolve it and refuse anything outside the project.
    path = (PROJECT / arg).resolve()
    if not path.is_relative_to(PROJECT):
        raise ValueError(f"{arg} is outside the project")
    return path

def run_tests(arg):
    path = inside_project(arg)
    if not (path.is_file() and path.name.startswith("test_") and path.suffix == ".py"):
        raise ValueError(f"{arg} is not a test file")
    result = subprocess.run(["pytest", str(path), "-q"], capture_output=True, text=True)
    return result.stdout[-2000:]

def read_file(arg):
    path = inside_project(arg)
    if not path.is_file() or path.suffix not in READABLE:
        raise ValueError(f"{arg} is not a file this agent may read")
    return path.read_text()[:20000]

TOOLS = {"run_tests": run_tests, "read_file": read_file}

def react(task, system_prompt, max_steps=8):
    transcript = f"Task: {task}\n"
    for _ in range(max_steps):
        response = client.chat.completions.create(
            model=MODEL,
            messages=[
                {"role": "system", "content": system_prompt},
                {"role": "user", "content": transcript},
            ],
            temperature=0,
        )
        text = response.choices[0].message.content
        match = re.search(r"Action: (\w+)\[(.*)\]", text)
        if not match:
            return text
        transcript += text[: match.end()] + "\n"
        tool, arg = match.groups()
        if tool == "finish":
            return arg
        try:
            observation = TOOLS[tool](arg) if tool in TOOLS else f"Unknown tool: {tool}"
        except Exception as error:  # a missing file becomes an observation, not a crash
            observation = f"Error: {error}"
        transcript += f"Observation:\n{observation}\n"
    return "Stopped after max_steps without an answer."

Vier Details sind wichtig. Das Protokoll wird direkt nach der Action abgeschnitten, weil Modelle manchmal weiterschreiben und ihre eigene Observation erfinden. Ein fehlschlagendes Tool (etwa ein falscher Dateiname) wird zu einer Observation, auf die das Modell reagieren kann, statt die Schleife abstürzen zu lassen. Das Schrittlimit stoppt ein Modell, das endlos kreist. Und die Testausgabe wird gekürzt, da ein riesiges Testlog das Kontextfenster füllen würde; zu entscheiden, was in dieses Fenster kommt, ist Context Engineering. Wenn du die Labels im System-Prompt übersetzt, etwa zu "Aktion:", musst du auch den regulären Ausdruck und die Zeichenketten Task: und Observation: im Code anpassen.

Die beiden Tools prüfen außerdem ihr Argument, bevor sie irgendetwas tun. Das Argument wählt das Modell, also gehören die Grenzen ins Tool: inside_project lehnt jeden Pfad ab, der außerhalb des Projektordners landet (auch mit ../), run_tests akzeptiert nur test_*.py-Dateien, und read_file öffnet nur wenige Code- und Textdateitypen und liefert höchstens 20.000 Zeichen, damit eine .env-Datei oder ein SSH-Schlüssel nie in der nächsten Anfrage landet. pytest führt trotzdem den Code deines Projekts aus, also lass einen solchen Agenten in einem Container oder einer Wegwerfkopie laufen, nie auf einem Rechner mit Geheimnissen.

Aktuelle APIs von OpenAI, Anthropic und Google bieten außerdem natives Tool Calling: Du beschreibst jedes Tool mit einem Namen und einem JSON-Schema, und das Modell gibt statt einer Action:-Zeile einen strukturierten Tool-Aufruf zurück. Die Schleife ist identisch; nur das Parsen entfällt.

Sicherheit in einer ReAct-Schleife

Ein Agent liest Text, den er nicht selbst geschrieben hat: Webseiten, Dateien, Tool-Ausgaben. Jeder davon kann Anweisungen enthalten, die auf das Modell zielen, und das ist Prompt Injection. Gib jedem Tool nur den Zugriff, den es braucht (wo möglich nur Lesezugriff), lass einen Menschen alles bestätigen, was löscht, verschickt oder bezahlt, und behandle die angeforderten Aktionen des Modells als nicht vertrauenswürdigen Input, den du prüfst, nicht als Befehle, die du blind ausführst.