Den vollständigen Index der Dokumentation findest du in llms.txt. Die Markdown-Version einer Dokumentationsseite erhältst du, indem du .md an die URL der Seite anhängst.
Hauptnavigation
Design

Reasoning-Modelle

Erfahre, wie Reasoning-Modelle funktionieren und wie du sie gezielt einsetzt.

Reasoning-Modelle verwenden interne Reasoning-Token, bevor sie eine Antwort ausgeben. So kann das Modell planen, Tools gezielt einsetzen, Alternativen prüfen, bei Mehrdeutigkeit einen Lösungsweg finden und schwierigere Aufgaben in mehreren Schritten lösen. Reasoning-Modelle eignen sich besonders für komplexe Probleme, Programmieraufgaben, wissenschaftliches Reasoning und mehrstufige Workflows mit Agenten. Sie sind auch die besten Modelle für Codex CLI, unseren schlanken Programmieragenten.

Beginne für die meisten Reasoning-Aufgaben mit gpt-6-astra. Für geringere Kosten kommt gpt-5.6-terra infrage. Die niedrigsten Kosten und die geringste Latenz bietet gpt-5.6-luna. Wenn du ein Modell der Familie GPT-5.6 oder GPT-6 verwendest, findest du im Abschnitt Reasoning-Modus Informationen zur Option pro.

Reasoning-Modelle arbeiten mit der Responses API besser. Die Chat Completions API wird weiterhin unterstützt. Mit der Responses API löst das Modell Aufgaben jedoch besser und erreicht eine höhere Leistung.

Einstieg in das Reasoning

Rufe die Responses API auf und gib das Reasoning-Modell und den Reasoning-Aufwand an:

Ein Reasoning-Modell in der Responses API verwenden
from openai import OpenAI

client = OpenAI()

prompt = """
Write a bash script that takes a matrix represented as a string with
format '[1,2],[3,4],[5,6]' and prints the transpose in the same format.
"""

response = client.responses.create(
    model="gpt-6-astra",
    reasoning={"effort": "low"},
    input=[{"role": "user", "content": prompt}],
)

print(response.output_text)

Reasoning-Aufwand

Der Parameter reasoning.effort gibt dem Modell vor, wie gründlich es eine Aufgabe durchdenken soll.

Welche Werte unterstützt werden, hängt vom Modell ab. Mögliche Werte sind none, minimal, low, medium, high, xhigh und max. Bei geringerem Aufwand antwortet das Modell in der Regel schneller und verbraucht weniger Token. Bei höherem Aufwand durchdenkt es die Aufgabe gründlicher, um bessere Antworten zu liefern. Bei allen Aufwandsstufen passen die Modelle ihr Reasoning an die Aufgabe an. Für einfache Aufgaben verwenden sie weniger Token, komplexe Aufgaben durchdenken sie intensiver.

GPT-6 Astra unterstützt den Reasoning-Aufwand none nicht. Setzt du reasoning.effort (Responses) oder reasoning_effort (Chat Completions) auf none, gibt die API den HTTP-Statuscode 400 zurück. GPT-6.1 Sol unterstützt weder none noch minimal und verwendet standardmäßig medium.

Verwende für Funktionsaufrufe die Responses API. Chat Completions unterstützt mit GPT-6 Astra und GPT-6.1 Sol keine Funktionsaufrufe.

Auch die Standardwerte hängen vom Modell ab. gpt-5.5 verwendet standardmäßig den Reasoning-Aufwand medium. Das ist für gpt-5.5 der beste Ausgangspunkt, um Qualität, Zuverlässigkeit und Leistung in Einklang zu bringen.

Aufwand Besonders geeignet für
none Zeitkritische Aufgaben, die weder von Reasoning noch von verketteten Tool-Aufrufen profitieren. Für latenzempfindliche Anwendungen mit gpt-5.5 empfehlen wir, zunächst low auszuprobieren und bei Bedarf auf none zu wechseln.

Typische Anwendungen sind Sprachinteraktion, schneller Informationsabruf und Klassifikation.
low Effizientes Reasoning bei leicht erhöhter Latenz. Ideal, wenn das Modell Tools verwenden, planen, suchen oder mehrstufige Entscheidungen treffen soll und es zugleich auf Geschwindigkeit und Kosten ankommt.

Typische Anwendungen sind Datenanalyse, das Erstellen von Entwürfen, die Umsetzung konkreter Programmieraufgaben sowie Workflows im Kundensupport oder mit Chat-Assistenten.
medium Aufgaben, bei denen Qualität und Zuverlässigkeit zählen und die Planung, komplexes Reasoning und Urteilsvermögen erfordern. Diese Standardeinstellung für die meisten Aufgaben bietet auf der Pareto-Kurve ein ausgewogenes Verhältnis von Latenz, Leistung und Kosten.

Typische Anwendungen sind agentisches Programmieren, Recherche, die Arbeit mit Tabellen und Präsentationsfolien sowie das Delegieren längerfristiger Aufgaben.
high Anspruchsvolles Reasoning, komplexe Fehlersuche, detaillierte Planung und besonders wichtige Aufgaben, bei denen Qualität und Modellintelligenz mehr zählen als Latenz. Empfohlen für komplexe Workflows und Aufgaben mit Agenten.

Typische Anwendungen sind agentisches Programmieren, langfristige Forschung und Wissensarbeit. Prüfe je nach Komplexität der Aufgabe sowohl medium als auch high.
xhigh Deep Research, asynchrone Workflows und Aufgaben mit Agenten, die lange Laufzeiten erfordern. Verwende diese Stufe nur, wenn deine Evaluierungen einen klaren Vorteil zeigen, der die zusätzliche Latenz und die höheren Kosten rechtfertigt.

Typische Anwendungen sind Sicherheitsprüfungen und Codeprüfungen, produktiveres Arbeiten in Unternehmen, vertiefte Recherche und anspruchsvolle Programmierabläufe.
max Maximaler Reasoning-Aufwand für deine komplexesten Aufgaben. Wenn du derzeit xhigh verwendest, prüfe, ob max bessere Ergebnisse liefert.

Wenn in einer latenzempfindlichen Anwendung das erste sichtbare Token früher erscheinen soll, bitte das Modell, vor dem vertieften Reasoning eine kurze Einleitung auszugeben.

Manche Modelle unterstützen nur einen Teil dieser Werte. Prüfe daher die jeweilige Modellseite, bevor du eine Einstellung wählst.

Reasoning-Modus

Modelle der Familien GPT-5.6 und GPT-6 unterstützen in der Responses API die Reasoning-Modi standard und pro. Standardmäßig gilt standard. Setze reasoning.mode auf pro, wenn eine schwierige Aufgabe mehr Rechenarbeit vom Modell erfordert und eine höhere Latenz sowie ein höherer Token-Verbrauch vertretbar sind.

Reasoning-Modus und Reasoning-Aufwand lassen sich unabhängig voneinander einstellen. Mit dem Modus wählst du zwischen Standard- und Pro-Ausführung. reasoning.effort steuert, wie gründlich das Modell die Aufgabe im jeweiligen Modus durchdenkt. Wenn du reasoning.effort weglässt, verwendet GPT-5.6 in beiden Modi standardmäßig medium. GPT-6.1 Sol, GPT-6 Sol und GPT-6 Luna verwenden ebenfalls standardmäßig den Reasoning-Aufwand medium.

Den Pro-Modus für Reasoning verwenden
curl https://api.openai.com/v1/responses \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer $OPENAI_API_KEY" \
  -d '{
    "model": "gpt-6.1-sol",
    "reasoning": {
      "mode": "pro",
      "effort": "medium"
    },
    "input": "Review this database migration plan and identify potential failure modes."
  }'

Im Pro-Modus wird die gesamte Rechenarbeit des Modells für die endgültige Antwort zusammengezählt. Die dabei anfallenden Token werden zu den regulären Token-Preisen des gewählten Modells abgerechnet. Im Pro-Modus leistet das Modell mehr Rechenarbeit als im Standardmodus. Dadurch steigen Token-Verbrauch und Kosten. Für bestehende Pro-Modell-IDs gelten weiterhin das bisherige Verhalten und die bisherigen Preise.

So funktioniert Reasoning

Reasoning-Modelle verwenden neben Eingabe- und Ausgabe-Token auch Reasoning-Token. Damit „denken“ die Modelle nach. Sie zerlegen den Prompt in Teilaufgaben und prüfen verschiedene Ansätze für eine Antwort. Unsere Reasoning-Modelle wie gpt-5.5 und gpt-5.4 können zwischen Reasoning und Ausgabe wechseln. Das Modell kann sowohl vor als auch zwischen Denkphasen sichtbare Ausgabe-Token erzeugen und zwischen Tool-Aufrufen weiterdenken.

Modelle, die vor GPT-5.6 erschienen sind, übernehmen in Gesprächen mit mehreren Schritten standardmäßig die Eingabe- und Ausgabe-Token jedes Schritts. Das Reasoning früherer Gesprächsrunden beziehen sie bei der nächsten Generierung nicht ein. Modelle der Familie GPT-5.6 beziehen verfügbares Reasoning aus früheren Runden standardmäßig ein. Bei unterstützten Modellen kannst du mit reasoning.context zwischen diesen beiden Verhaltensweisen wählen.

Reasoning-Token mit dem Kontext der aktuellen Gesprächsrunde

Reasoning-Token sind über die API nicht sichtbar. Sie belegen dennoch Platz im Kontextfenster des Modells und werden als Ausgabe-Token abgerechnet.

Kosten steuern

Um die Kosten bei Reasoning-Modellen zu steuern, kannst du die Gesamtzahl der vom Modell erzeugten Token mit dem Parameter max_output_tokens begrenzen. Das Limit umfasst Reasoning-Token, sichtbare Ausgabe-Token und unsichtbare Formatierungs-Token. Wie erzeugte Token beim Verbrauch und bei den Ausgabelimits berücksichtigt werden, erfährst du im Abschnitt zur Zählung der Ausgabe-Token.

Das Kontextfenster verwalten

Achte beim Erstellen von Antworten darauf, dass im Kontextfenster genügend Platz für Reasoning-Token bleibt. Je nach Komplexität des Problems können die Modelle wenige Hundert bis mehrere Zehntausend Reasoning-Token erzeugen. Die genaue Anzahl findest du in den Nutzungsdaten des Antwortobjekts unter output_tokens_details:

{
  "usage": {
    "input_tokens": 75,
    "input_tokens_details": {
      "cached_tokens": 0
    },
    "output_tokens": 1186,
    "output_tokens_details": {
      "reasoning_tokens": 1024
    },
    "total_tokens": 1261
  }
}

Die Größe des Kontextfensters findest du in der Modellreferenz. Sie kann je nach Modell-Snapshot variieren.

Platz für Reasoning einplanen

Erreichen die erzeugten Token die Grenze des Kontextfensters oder den von dir festgelegten Wert für max_output_tokens, erhältst du eine Antwort mit dem status-Wert incomplete. In incomplete_details hat reason dann den Wert max_output_tokens. Das kann passieren, bevor das Modell sichtbare Ausgabe-Token erzeugt. In diesem Fall können Kosten für Eingabe- und Reasoning-Token anfallen, ohne dass du eine sichtbare Antwort erhältst.

Um das zu vermeiden, plane genügend Platz im Kontextfenster ein oder erhöhe den Wert für max_output_tokens. OpenAI empfiehlt, bei den ersten Versuchen mit diesen Modellen mindestens 25.000 Token für Reasoning und Ausgaben zu reservieren. Sobald du einschätzen kannst, wie viele Reasoning-Token deine Prompts erfordern, kannst du diesen Puffer anpassen.

Unvollständige Antworten verarbeiten
from openai import OpenAI

client = OpenAI()

prompt = """
Write a bash script that takes a matrix represented as a string with
format '[1,2],[3,4],[5,6]' and prints the transpose in the same format.
"""

response = client.responses.create(
    model="gpt-6-astra",
    reasoning={"effort": "medium"},
    input=[{"role": "user", "content": prompt}],
    max_output_tokens=300,
)

if (
    response.status == "incomplete"
    and response.incomplete_details.reason == "max_output_tokens"
):
    print("Ran out of tokens")
    if response.output_text:
        print("Partial output:", response.output_text)
    else:
        print("Ran out of tokens during reasoning")

Reasoning über mehrere Aufrufe hinweg beibehalten

Gesprächszustand und Reasoning-Zustand erfüllen unterschiedliche Zwecke. Wenn du Nachrichten bei weiteren Aufrufen mitgibst, erhält das Modell den sichtbaren Gesprächsverlauf. Unterstützte Modelle können mithilfe des beibehaltenen Reasoning-Zustands außerdem kompatible Reasoning-Elemente aus früheren Runden in den nächsten Kontext übernehmen.

So kann das Modell an seine bisherigen Überlegungen anknüpfen. Die internen Denkschritte bleiben verborgen. Der Inhalt der Reasoning-Elemente lässt sich nicht einsehen, und die API gibt den zugehörigen Text nicht zurück. Mit reasoning.context steuerst du, welche verfügbaren Reasoning-Elemente das Modell verwenden kann:

Die Modellfamilie GPT-5.6 unterstützt all_turns und verwendet diesen Wert standardmäßig. Frühere Modelle verwenden standardmäßig current_turn. GPT-6.1 Sol unterstützt ebenfalls all_turns. Lass reasoning.context weg oder setze den Parameter auf auto, um den Standardwert des gewählten Modells zu verwenden.

Wert Verhalten
auto Verwendet den Standardwert des gewählten Modells. Wenn du reasoning.context weglässt, hat das dieselbe Wirkung wie auto.
current_turn Stellt das Reasoning der aktuellen Gesprächsrunde bereit. Reasoning aus früheren Runden fließt bei der nächsten Generierung nicht ein.
all_turns Bezieht verfügbare, kompatible Reasoning-Elemente aus früheren Gesprächsrunden bei der nächsten Generierung ein. Modelle der Familie GPT-5.6 und GPT-6.1 Sol unterstützen diesen Wert.

Das Feld reasoning.context in der Antwort enthält den tatsächlich verwendeten Modus, entweder current_turn oder all_turns. Prüfe das Feld bei jeder Antwort, um festzustellen, welchen Modus das Modell verwendet hat. Die Einstellung erzeugt keine zusätzlichen Reasoning-Elemente.

all_turns wirkt sich nur aus, wenn die Anfrage Zugriff auf frühere Antwortelemente hat. Verwende previous_response_id, ordne die Antwort einem Gespräch zu oder übergib den vollständigen Antwortverlauf manuell erneut. Bei der ersten Anfrage verhalten sich current_turn und all_turns gleich, da noch kein früheres Reasoning vorliegt.

Das Modell kann früheres Reasoning nur innerhalb derselben Modellfamilie wiederverwenden. Beispielsweise können gpt-5.6-sol, gpt-5.6-terra und gpt-5.6-luna das Reasoning der jeweils anderen Modelle verwenden. Zwischen den Familien GPT-5.6 und GPT-5.5 lässt es sich hingegen nicht übertragen.

Wenn du die Modellfamilie wechselst, lässt die API inkompatibles Reasoning im Modellkontext weg, auch wenn reasoning.context auf all_turns gesetzt ist.

Reasoning mit gespeicherten Antworten fortsetzen

Am einfachsten behältst du den Zustand zwischen Aufrufen mit previous_response_id bei:

Reasoning aus einer früheren Antwort beibehalten
from openai import OpenAI

client = OpenAI()
model = "gpt-6.1-sol"

first = client.responses.create(
    model=model,
    input="Inspect this repository and identify the likely bug.",
    reasoning={"context": "current_turn"},
)

second = client.responses.create(
    model=model,
    previous_response_id=first.id,
    input="Now patch the bug and explain the change.",
    reasoning={"context": "all_turns"},
)

print(second.output_text)

Verwende current_turn, wenn du ältere Antwortelemente erneut übergibst, die das Modell nicht mehr benötigt. Die zugehörigen Reasoning-Elemente können in den API-Anfragedaten bleiben, damit der Verlauf vollständig bleibt. Der Dienst bezieht sie bei der neuen Generierung nicht ein. Bei länger laufenden Workflows kann das den tatsächlich verwendeten Kontext verkleinern.

Reasoning ohne gespeicherte Antworten beibehalten

Wenn du eine Antwort im zustandslosen Modus erstellst, enthalten die Reasoning-Elemente im output-Array der Antwort standardmäßig die Eigenschaft encrypted_content. Der zustandslose Modus gilt, wenn store auf false gesetzt ist oder deine Organisation die Einstellung „keine Datenaufbewahrung“ (ZDR) verwendet. Aus Kompatibilitätsgründen akzeptiert die API weiterhin den früher verwendeten Wert reasoning.encrypted_content in include. Die Angabe ist aber nicht erforderlich.

Die folgende Anfrage liefert verschlüsselte Reasoning-Inhalte, ohne include anzugeben:

curl https://api.openai.com/v1/responses \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer $OPENAI_API_KEY" \
  -d '{
    "model": "gpt-6-astra",
    "store": false,
    "reasoning": {"effort": "medium"},
    "input": "What is the weather like today?",
    "tools": [ ... function config here ... ]
  }'

Die Reasoning-Elemente im output-Array enthalten die Eigenschaft encrypted_content mit verschlüsselten Reasoning-Token, die du bei späteren Aufrufen mitgeben kannst.

Um all_turns mit store: false zu verwenden, behalte jedes Ausgabeelement bei, hänge die nächste Nutzernachricht an und übergib den vollständigen Verlauf erneut:

Reasoning beibehalten, ohne Antworten zu speichern
from openai import OpenAI

client = OpenAI()
model = "gpt-6.1-sol"

history = [
    {
        "role": "user",
        "content": "Inspect this repository and identify the likely bug.",
    }
]

first = client.responses.create(
    model=model,
    store=False,
    input=history,
    reasoning={"context": "current_turn"},
)

# Keep every output item, including encrypted reasoning and assistant phase.
history.extend(item.to_dict() for item in first.output)
history.append(
    {
        "role": "user",
        "content": "Now patch the bug and explain the change.",
    }
)

second = client.responses.create(
    model=model,
    store=False,
    input=history,
    reasoning={"context": "all_turns"},
)

print(second.output_text)

Reasoning-Elemente im Kontext behalten

Wenn du Funktionsaufrufe mit einem Reasoning-Modell in der Responses API verwendest, gib die Reasoning-Elemente, die du mit den Funktionsaufrufen erhältst, zusammen mit den Tool-Ausgaben zurück. So kann das Modell sein Reasoning nach einem Tool-Aufruf fortsetzen.

Mit previous_response_id kannst du Reasoning-Elemente in die nächste Anfrage übernehmen. Wenn du den Gesprächsverlauf selbst verwaltest, übergib die ursprüngliche Eingabe und alle Ausgabeelemente jeder Antwort als Eingabe für die nächste Anfrage. Behalte die ursprüngliche Reihenfolge der Elemente bei und hänge neue Elemente am Ende an.

Wenn du bei neueren Frontier-Modellen den Gesprächsverlauf vor einem Reasoning-Element änderst, kann die API das zugehörige Reasoning verwerfen. Im Leitfaden Das Präfix unverändert lassen erfährst du, worauf du achten solltest, wenn du Anweisungen oder Tool-Ausgaben änderst oder lange Gespräche verwaltest.

Reasoning-Aufwand während des Gesprächs ändern

Verwende configuration_update, um den Reasoning-Aufwand für schwierige Aufgaben zu erhöhen oder für einfache Folgefragen zu senken. Füge die Änderung zwischen zwei Antworten ein und behalte den Wert von reasoning.effort auf Anfrageebene bei. So bleibt das ursprüngliche Prompt-Präfix für das Prompt-Caching erhalten.

Bei Modellen ab GPT-6, die Konfigurationsänderungen unterstützen, kannst du im Standardmodus mit einem einzelnen Agenten den Reasoning-Aufwand und das Antwortformat ändern.

Füge das folgende Element vor der nächsten Nutzernachricht in das input-Array ein. Das gilt sowohl für eine HTTP-Anfrage an die Responses API als auch für eine WebSocket-Anfrage mit response.create:

{
  "type": "configuration_update",
  "reasoning": {
    "effort": "high"
  }
}

Beginnt das Gespräch beispielsweise mit dem Reasoning-Aufwand low auf Anfrageebene, gilt nach dieser Änderung high für die nächste und alle weiteren Antworten, bis eine weitere Änderung den Wert überschreibt.

Reasoning-Aufwand für eine Folgefrage erhöhen
from openai import OpenAI

client = OpenAI()
model = "gpt-6-astra"

response = client.responses.create(
    model=model,
    reasoning={"effort": "low"},
    input="Draft a database migration plan.",
    store=True,
)
print(response.output_text)

response = client.responses.create(
    model=model,
    previous_response_id=response.id,
    reasoning={"effort": "low"},
    input=[
        {
            "type": "configuration_update",
            "reasoning": {"effort": "high"},
        },
        {
            "role": "user",
            "content": "Analyze the failure modes and propose rollback steps.",
        },
    ],
    store=True,
)
print(response.output_text)

Behalte die Änderungen mit previous_response_id bei oder übergib sie erneut an ihren ursprünglichen Positionen, wenn du den Gesprächsverlauf manuell verwaltest. Das Feld reasoning.effort in der Antwort gibt weiterhin die Einstellung auf Anfrageebene an. Der durch die Änderung gewählte Aufwand wird dort nicht angezeigt.

Du kannst reasoning.effort und text.format im selben configuration_update-Element festlegen. Änderst du nur eine der beiden Einstellungen, bleibt die andere erhalten.

Kombiniere Konfigurationsänderungen weder mit automatischer Kontextverdichtung noch mit automatischer Kürzung. Auch der separate Endpunkt /responses/compact lehnt Gesprächsverläufe mit solchen Änderungen ab.

Du kannst die Verdichtung des Verlaufs weiterhin gezielt auslösen, indem du ein compaction_trigger-Element in eine /responses-Anfrage aufnimmst. Füge nach der Kontextverdichtung vor der nächsten Nutzernachricht ein neues configuration_update ein. Gib darin jede Einstellung, die du geändert hast, erneut an. Das gilt auch für das Antwortformat, falls du es geändert hast.

Für das Prompt-Caching gelten weiterhin die üblichen Voraussetzungen. Wie du Anweisungen übermittelst, während das Modell eine Antwort generiert, erfährst du im Leitfaden zur Steuerung während einer Gesprächsrunde.

Reasoning-Zusammenfassungen

Die vom Modell erzeugten internen Reasoning-Token sind nicht einsehbar. Mit dem Parameter summary kannst du dir jedoch eine Zusammenfassung der Überlegungen des Modells anzeigen lassen. Welche Reasoning-Modelle Zusammenfassungen unterstützen, erfährst du in unserer Modelldokumentation.

Die verfügbaren Einstellungen für Reasoning-Zusammenfassungen hängen vom Modell ab. Unser Modell für die Computernutzung unterstützt beispielsweise concise, während o4-mini detailed unterstützt. Setze den Parameter auf auto, um die ausführlichste für das jeweilige Modell verfügbare Zusammenfassung zu erhalten. auto entspricht bei den meisten aktuellen Reasoning-Modellen detailed. Künftig könnte es feinere Abstufungen geben.

Die Reasoning-Zusammenfassung steht im summary-Array des reasoning-Ausgabeelements. Sie ist nur enthalten, wenn du sie ausdrücklich anforderst.

Das folgende Beispiel zeigt, wie du mit einer API-Anfrage eine Reasoning-Zusammenfassung anforderst.

Eine Reasoning-Zusammenfassung mit der API-Antwort anfordern
from openai import OpenAI

client = OpenAI()

response = client.responses.create(
    model="gpt-6-astra",
    input="What is the capital of France?",
    reasoning={"effort": "low", "summary": "auto"},
)

print(response.output)

Diese API-Anfrage liefert ein Ausgabearray mit einer Assistenznachricht und einer Zusammenfassung der Überlegungen, die zu dieser Antwort geführt haben.

[
  {
    "id": "rs_6876cf02e0bc8192b74af0fb64b715ff06fa2fcced15a5ac",
    "type": "reasoning",
    "summary": [
      {
        "type": "summary_text",
        "text": "**Answering a simple question**\n\nI\u2019m looking at a straightforward question: the capital of France is Paris. It\u2019s a well-known fact, and I want to keep it brief and to the point. Paris is known for its history, art, and culture, so it might be nice to add just a hint of that charm. But mostly, I\u2019ll aim to focus on delivering a clear and direct answer, ensuring the user gets what they\u2019re looking for without any extra fluff."
      }
    ]
  },
  {
    "id": "msg_6876cf054f58819284ecc1058131305506fa2fcced15a5ac",
    "type": "message",
    "status": "completed",
    "content": [
      {
        "type": "output_text",
        "annotations": [],
        "logprobs": [],
        "text": "The capital of France is Paris."
      }
    ],
    "role": "assistant"
  }
]

Bevor du Zusammenfassungen mit unseren neuesten Reasoning-Modellen verwendest, musst du für einen sicheren Einsatz gegebenenfalls die Verifizierung deiner Organisation abschließen. Du kannst die Verifizierung in den Plattformeinstellungen starten.

Der Parameter phase

Verwende bei lang laufenden Abläufen oder häufigen Tool-Aufrufen mit GPT-5.5 und GPT-5.4 in der Responses API das Feld phase der Assistenznachricht. So vermeidest du vorzeitige Abbrüche und anderes Fehlverhalten. Die API erfordert phase nicht, OpenAI empfiehlt jedoch die Verwendung. Nutze phase: "commentary" für Zwischenmeldungen des Assistenten, etwa für kurze Einleitungen vor Tool-Aufrufen, und phase: "final_answer" für die endgültige Antwort. Füge phase nicht zu Nutzernachrichten hinzu. Mit previous_response_id ist es meist am einfachsten, da der bisherige Zustand des Assistenten erhalten bleibt. Wenn du frühere Assistenznachrichten manuell erneut übergibst, behalte jeden ursprünglichen phase-Wert bei. Fehlt phase oder geht das Feld verloren, können Einleitungen in solchen Abläufen als endgültige Antworten gelten. Modellspezifische Empfehlungen findest du im Abschnitt Prompts für GPT-5.5.

Phasenwerte aus Assistenznachrichten erneut übergeben

Phasenwerte aus Assistenznachrichten erneut übergeben
from openai import OpenAI

client = OpenAI()

response = client.responses.create(
    model="gpt-6-astra",
    input=[
        {
            "role": "assistant",
            "phase": "commentary",
            "content": "I’ll inspect the logs and then summarize root cause and remediation.",
        },
        {
            "role": "assistant",
            "phase": "final_answer",
            "content": "Root cause: cache invalidation race.",
        },
        {
            "role": "user",
            "content": "Great—now give me a rollout-safe fix plan.",
        },
    ],
)

print(response.output_text)

Tipps für Prompts

Berücksichtige beim Formulieren von Prompts für Reasoning-Modelle die folgenden Besonderheiten. GPT-5-Modelle mit Reasoning-Fähigkeiten liefern meist die besten Ergebnisse, wenn du ein klares Ziel, eindeutige Vorgaben und genaue Anforderungen an die Ausgabe formulierst, ohne jeden Zwischenschritt vorzuschreiben.

  • Nenne dem Modell die Aufgabe, die Vorgaben und das gewünschte Ausgabeformat.
  • Nutze reasoning.effort zur Feinabstimmung. Bei unzureichender Qualität sollte dieser Parameter nicht dein erster Ansatz sein.
  • Lege für Workflows mit Agenten oder umfangreicher Recherche fest, wann die Aufgabe abgeschlossen ist und wie das Modell seine Arbeit überprüfen soll.

Weitere Empfehlungen zum Einsatz von Reasoning-Modellen findest du in diesem Leitfaden.

Prompt-Beispiele

Reasoning-Modelle können komplexe Algorithmen implementieren und Code schreiben. Mit diesem Prompt forderst du das Modell auf, eine React-Komponente nach vorgegebenen Kriterien zu refaktorieren.

Code refaktorieren
import OpenAI from "openai";

const openai = new OpenAI();

const prompt = `
Instructions:
- Given the React component below, change it so that nonfiction books have red
  text.
- Return only the code in your reply
- Do not include any additional formatting, such as markdown code blocks
- For formatting, use four space tabs, and do not allow any lines of code to
  exceed 80 columns

const books = [
  { title: 'Dune', category: 'fiction', id: 1 },
  { title: 'Frankenstein', category: 'fiction', id: 2 },
  { title: 'Moneyball', category: 'nonfiction', id: 3 },
];

export default function BookList() {
  const listItems = books.map(book =>
    <li>
      {book.title}
    </li>
  );

  return (
    <ul>{listItems}</ul>
  );
}
`.trim();

const response = await openai.responses.create({
  model: "gpt-6-astra",
  input: [
    {
      role: "user",
      content: prompt,
    },
  ],
});

console.log(response.output_text);

Anwendungsbeispiele

Beispiele für den praktischen Einsatz von Reasoning-Modellen findest du im Cookbook.

Daten mit Reasoning validieren

Prüfe einen synthetischen medizinischen Datensatz auf Unstimmigkeiten.

Routinen mit Reasoning erstellen

Leite aus Artikeln des Hilfecenters Aktionen ab, die ein Agent ausführen könnte.