Thinking

Ein Modell, das in einem einzigen Durchgang antwortet, muss beim ersten Versuch alles richtig machen: keine Nebenrechnungen, kein Überprüfen, kein Kurswechsel auf halbem Weg. Bei einem Beweis, einem kniffligen Bug oder einer langen agentischen Aufgabe ist der erste Ansatz oft nicht der beste.

Thinking (Denken) hebt diese Einschränkung auf. Wenn Thinking aktiv ist, arbeitet Claude das Problem in eigenen Worten durch, bevor es antwortet: Es formuliert neu, was gefragt wird, probiert Ansätze aus, überprüft Zwischenergebnisse und verwirft Wege, die nicht standhalten. Dieses Reasoning kommt in thinking-Content-Blöcken vor der Antwort an, und Claude greift darauf zurück, um die endgültige Antwort zu erstellen. Deshalb verbessert Thinking die Leistung bei komplexen Aufgaben wie Mathematik, Programmierung, Analyse und langlaufender agentischer Arbeit, bei denen die Qualität der Antwort von Zwischenarbeit abhängt, die sonst in die Antwort selbst komprimiert oder übersprungen würde.

Thinking hat seinen Preis: Die Token, die Claude für das Reasoning aufwendet, werden als Output-Token abgerechnet, auch wenn der Thinking-Text nicht an dich zurückgegeben wird, und sie zählen neben dem Antworttext zu max_tokens. Diese Seite behandelt, wie sich Thinking über die API-Oberfläche hinweg verhält: das Einschalten, das Lesen der Ausgabe und das Verwalten der Interaktionen mit Tools, Streaming, Caching und dem Kontextfenster.



Wie Thinking funktioniert

Ob Claude bei einer bestimmten Anfrage denkt und wie tief, hängt von deiner Thinking-Konfiguration und der Komplexität der Anfrage ab.

So sieht Thinking in einer Antwort aus: Ein oder mehrere thinking-Content-Blöcke kommen vor den text-Blöcken an. Der Thinking-Block ist weiterhin generierter Inhalt, wie der text-Block, der ihm folgt, aber er ist von der kanonischen Antwort getrennt. Jeder Thinking-Block trägt außerdem ein signature-Feld, eine verschlüsselte Kopie des vollständigen Reasonings, die du in Multi-Turn- und Tool-Nutzungs-Konversationen unverändert zurückgibst (siehe Thinking-Verschlüsselung):

{
  "content": [
    {
      "type": "thinking",
      "thinking": "Let me break this down. The question has two parts, so I'll start with the simpler one and use its result to constrain the second...",
      "signature": "WaUjzkypQ2mUEVM36O2Txu...."
    },
    {
      "type": "text",
      "text": "Based on my analysis..."
    }
  ]
}

Du siehst diesen Text nicht immer, und was du siehst, ist nie die rohe Gedankenkette: Der Text in einem Thinking-Block ist eine Zusammenfassung von Claudes Reasoning. Das display-Feld in der Thinking-Konfiguration steuert, ob diese Zusammenfassung überhaupt zurückgegeben wird: "summarized" gibt sie zurück, während "omitted", der Standard bei den neuesten Modellen, Thinking-Blöcke mit einem leeren thinking-Feld zurückgibt. In beiden Fällen wird der Block gleich abgerechnet und in Multi-Turn-Konversationen gleich zurückgegeben. Siehe Thinking-Anzeige steuern für modellspezifische Standardwerte und Details.

Wenn Claude Tools verwendet, kann Thinking auch zwischen Tool-Aufrufen erscheinen. Siehe Thinking mit Tool-Nutzung. Das vollständige Antwortformat findest du in der Messages-API-Referenz.



Thinking konfigurieren

Bei aktuellen Modellen ist Thinking standardmäßig aktiviert oder nur einen Parameter entfernt. Welche Konfiguration jedes Modell akzeptiert und was der Standard ist, findest du in der modellspezifischen Konfigurationstabelle auf der Troubleshooting-Seite.

Bei Claude Opus 5, Claude Sonnet 5, Claude Fable 5, Claude Mythos 5 und Claude Mythos Preview ist Thinking bereits aktiviert: keine Konfiguration nötig. Das Erste, was die meisten Entwickler bei diesen Modellen brauchen, ist, den Thinking-Text zu sehen, weil display dort standardmäßig auf "omitted" steht. Aktiviere es mit thinking: {"type": "adaptive", "display": "summarized"}, was genau der folgenden Anfrage mit ausgetauschtem Modell-String entspricht.

Bei Claude Opus 4.8, Claude Opus 4.7, Claude Opus 4.6 und Claude Sonnet 4.6 ist Thinking deaktiviert, bis du thinking: {type: "adaptive"} setzt, wodurch Claude basierend auf der Anfrage entscheidet, wann und wie tief es denkt. Die folgenden Beispiele tun das, setzen display: "summarized", damit der Thinking-Text sichtbar ist, und verwenden ein großzügiges max_tokens:

client = anthropic.Anthropic()

response = client.messages.create(
    model="claude-opus-4-8",
    max_tokens=16000,
    thinking={"type": "adaptive", "display": "summarized"},
    messages=[
        {
            "role": "user",
            "content": "What is the greatest common divisor of 1071 and 462?",
        }
    ],
)

for block in response.content:
    if block.type == "thinking":
        print(f"\nThinking: {block.thinking}")
    elif block.type == "text":
        print(f"\nResponse: {block.text}")

Das Ausführen des Beispiels gibt das zusammengefasste Thinking aus, dann die Antwort:

Thinking: Use Euclidean algorithm.
1071 = 2*462 + 147
462 = 3*147 + 21
147 = 7*21 + 0
GCD = 21

Response: ## Finding GCD of 1071 and 462

I'll use the **Euclidean algorithm**, repeatedly dividing and taking remainders...

Thinking-Token zählen zu max_tokens, also setze es hoch genug, um Platz für sowohl das Thinking als auch den Antworttext zu lassen. Siehe Kostenkontrolle auf der Steering-Seite und Thinking und das Kontextfenster.



Thinking ausschalten

Bei Claude Sonnet 5, wo Thinking standardmäßig aktiviert ist, kannst du es ausschalten:

client = anthropic.Anthropic()

response = client.messages.create(
    model="claude-sonnet-5",
    max_tokens=4096,
    thinking={"type": "disabled"},
    messages=[{"role": "user", "content": "Summarize this article in one sentence."}],
)

Claude Opus 5 hat Thinking ebenfalls standardmäßig aktiviert und akzeptiert thinking: {type: "disabled"} bei Effort high oder niedriger. Bei xhigh- oder max-Effort kann Thinking nicht ausgeschaltet werden: Anfragen, die thinking: {type: "disabled"} mit diesen Effort-Stufen kombinieren, geben einen 400-Fehler zurück. Diese Einschränkung gilt für Claude Opus 5 und spätere Modelle und wird bei jeder Anfrage durchgesetzt. Mit deaktiviertem Thinking kann Claude Opus 5 gelegentlich Tool-Aufrufe als Klartext ausgeben oder interne XML-Tags in seiner sichtbaren Ausgabe einschließen. Siehe Ausführen mit deaktiviertem Thinking für Prompting-Abhilfen.

Claude Fable 5, Claude Mythos 5 und Claude Mythos Preview lehnen thinking: {type: "disabled"} ab: Thinking kann bei diesen Modellen nicht ausgeschaltet werden.

Wenn dein Modell nur erweitertes Denken unterstützt (siehe die modellspezifische Konfigurationstabelle), konfiguriere es stattdessen mit type: "enabled" und einem budget_tokens-Wert. Die Seite Erweitertes Denken behandelt diese Konfiguration. Und wenn eine Thinking-Konfiguration mit einem 400-Fehler zurückkommt, ordnet Thinking-Troubleshooting jede Fehlermeldung ihrer Lösung zu.



Thinking-Ausgabe lesen



Thinking-Anzeige steuern

Das display-Feld in der Thinking-Konfiguration steuert, wie Thinking-Inhalte in API-Antworten zurückgegeben werden. display funktioniert in beiden Modi: Setze es zusammen mit type: "adaptive" oder type: "enabled". Es akzeptiert zwei Werte:

• "summarized": Thinking-Blöcke enthalten zusammengefassten Thinking-Text, eine lesbare Zusammenfassung von Claudes Reasoning. Dies ist der Standard bei Claude Opus 4.6, Claude Sonnet 4.6 und früheren Modellen.
• "omitted": Thinking-Blöcke werden mit einem leeren thinking-Feld zurückgegeben. Das signature-Feld trägt weiterhin das verschlüsselte vollständige Thinking für Multi-Turn-Kontinuität (siehe Thinking-Verschlüsselung). Dies ist der Standard bei Claude Fable 5, Claude Mythos 5, Claude Opus 5, Claude Sonnet 5, Claude Opus 4.8, Claude Opus 4.7 und Claude Mythos Preview.

Setze display: "omitted", wenn deine Anwendung Thinking-Inhalte nicht für Nutzer anzeigt. Der Hauptvorteil ist eine schnellere Time-to-First-Text-Token beim Streaming: Der Server überspringt das Streaming von Thinking-Token vollständig und liefert nur die Signatur, sodass die endgültige Textantwort früher zu streamen beginnt.

Mit display: "omitted" enthält die Antwort thinking-Blöcke mit einem leeren thinking-Feld:

{
  "content": [
    {
      "type": "thinking",
      "thinking": "",
      "signature": "EosnCkYICxIMMb3LzNrMu..."
    },
    {
      "type": "text",
      "text": "The answer is 12,231."
    }
  ]
}

Beachte Folgendes bei der Arbeit mit ausgelassenem Thinking:

• Dir werden weiterhin die vollständigen Thinking-Token berechnet. Das Auslassen reduziert die Latenz, nicht die Kosten.
• Wenn du Thinking-Blöcke in Multi-Turn-Konversationen zurückgibst, gib sie unverändert zurück. Der Server entschlüsselt die signature, um das ursprüngliche Thinking für die Prompt-Konstruktion zu rekonstruieren (siehe Thinking-Blöcke bewahren). Jeglicher Text, den du in das thinking-Feld eines zurückgesendeten ausgelassenen Blocks einfügst, wird ignoriert.
• display ist ungültig mit thinking.type: "disabled" (es gibt nichts anzuzeigen).
• Wenn du thinking.type: "adaptive" verwendest und das Modell das Thinking für eine einfache Anfrage überspringt, wird unabhängig von display kein Thinking-Block erzeugt.
• Beim Streaming mit display: "omitted" werden keine thinking_delta-Events ausgegeben. Siehe Thinking streamen für die Event-Sequenz.

Im Ruby-SDK nehmen einfache Hashes display: wie in den Beispielen gezeigt. Die typisierte ThinkingConfigAdaptive-Klasse benennt den Parameter display_ (mit nachgestelltem Unterstrich, um Rubys Kernel#display nicht zu überschatten). In beiden Fällen ist das Wire-Feld weiterhin display.



Zusammengefasstes Thinking

Wenn display auf "summarized" steht, ist der Thinking-Text, den du erhältst, eine Zusammenfassung von Claudes vollständigem Denkprozess und nicht die rohe Gedankenkette. Zusammengefasstes Thinking bietet die vollen Intelligenzvorteile von Thinking und verhindert gleichzeitig Missbrauch. Keine display-Einstellung gibt die rohe Gedankenkette zurück.

Beachte Folgendes bei der Arbeit mit zusammengefasstem Thinking:

• Dir werden die vollständigen Thinking-Token berechnet, die von der ursprünglichen Anfrage generiert wurden, nicht die Zusammenfassungs-Token. Die abgerechnete Output-Token-Anzahl stimmt nicht mit der Anzahl der Token überein, die du in der Antwort siehst.
• Bei Claude Opus 4.6, Claude Sonnet 4.6 und früheren Modellen sind die ersten Zeilen der Thinking-Ausgabe ausführlicher und liefern detailliertes Reasoning, das besonders für Prompt-Engineering-Zwecke hilfreich ist. Claude Mythos Preview fasst ab dem ersten Token zusammen, sodass seine Thinking-Blöcke diese ausführliche Präambel nicht zeigen.
• Die Zusammenfassung bewahrt die Kernideen von Claudes Denkprozess mit minimaler zusätzlicher Latenz, sodass Zusammenfassungen streamen können, während sie ankommen.
• Die Zusammenfassung wird von einem anderen Modell verarbeitet als dem, das du in deinen Anfragen ansprichst. Das Thinking-Modell sieht die zusammengefasste Ausgabe nicht.
• Da Anthropic bestrebt ist, das Thinking-Feature zu verbessern, kann sich das Zusammenfassungsverhalten ändern.



Thinking streamen

Thinking funktioniert mit Streaming. Thinking-Blöcke streamen als thinking_delta-Events innerhalb von content_block_delta-Events, gefolgt von einem einzelnen signature_delta-Event direkt vor dem content_block_stop des Blocks. Text-Blöcke streamen danach wie gewohnt.

Die folgenden Beispiele streamen eine Antwort mit adaptivem Thinking und geben Thinking- und Text-Deltas aus, während sie ankommen:

client = anthropic.Anthropic()

with client.messages.stream(
    model="claude-opus-4-8",
    max_tokens=16000,
    thinking={"type": "adaptive", "display": "summarized"},
    messages=[
        {
            "role": "user",
            "content": "What is the greatest common divisor of 1071 and 462?",
        }
    ],
) as stream:
    for event in stream:
        if event.type == "content_block_start":
            print(f"\nStarting {event.content_block.type} block...")
        elif event.type == "content_block_delta":
            if event.delta.type == "thinking_delta":
                print(event.delta.thinking, end="", flush=True)
            elif event.delta.type == "text_delta":
                print(event.delta.text, end="", flush=True)

Um vollständige Thinking-Blöcke mit ihren Signaturen nach dem Streaming wieder zusammenzusetzen, verwende den Message-Accumulation-Helper deines SDKs, wo einer existiert (zum Beispiel stream.get_final_message() in Python oder stream.finalMessage() in TypeScript), anstatt Deltas selbst zu verketten.

Wenn display: "omitted" gesetzt ist, öffnet sich der Thinking-Block, ein einzelnes signature_delta kommt an, und der Block schließt sich ohne thinking_delta-Events. Das Text-Streaming beginnt unmittelbar danach:

event: content_block_start
data: {"type":"content_block_start","index":0,"content_block":{"type":"thinking","thinking":"","signature":""}}

event: content_block_delta
data: {"type":"content_block_delta","index":0,"delta":{"type":"signature_delta","signature":"EosnCkYICxIMMb3LzNrMu..."}}

event: content_block_stop
data: {"type":"content_block_stop","index":0}

event: content_block_start
data: {"type":"content_block_start","index":1,"content_block":{"type":"text","text":""}}

Für allgemeine Streaming-Mechanik siehe Streaming Messages.



Thinking und Effort

Der thinking-Parameter steuert, ob Claude in Thinking-Blöcken denkt, bevor es antwortet; der effort-Parameter steuert, wie viel Arbeit Claude in die gesamte Antwort steckt, was im adaptiven Modus auch einschließt, wie oft und wie tiefgehend es denkt. Übergib nicht adaptive als effort-Wert: adaptive ist ein Thinking-Modus, keine Effort-Stufe.

Was jede Effort-Stufe mit dem Thinking-Verhalten macht, findest du in der Thinking-Verhaltenstabelle pro Stufe auf der Seite Thinking steuern. Die Effort-Seite dokumentiert den Parameter selbst, einschließlich welcher Stufen jedes Modell unterstützt. Bei Claude Opus 4.5, dem einzigen Modell mit ausschließlich erweitertem Denken, das Effort unterstützt, kombiniert sich Effort mit budget_tokens. Siehe Budget-Regeln und Tuning.

Da die beiden Steuerungen so getrennt sind, wähle diejenige, die zu deinem Ziel passt:

• Niedrigere Kosten oder Latenz bei einer Thinking-aktivierten Workload: senke zuerst effort. Es skaliert die gesamte Antwort herunter, einschließlich Thinking.
• Claude denkt zu selten oder zu oberflächlich: erhöhe effort, oder siehe Steuern, wie oft Claude denkt auf der Steering-Seite.
• Du brauchst Thinking vollständig ausgeschaltet: verwende thinking: {type: "disabled"} bei Modellen, die es erlauben (siehe die modellspezifische Konfigurationstabelle).
• Du brauchst eine harte Obergrenze für Ausgaben: verwende max_tokens. Effort ist weiche Orientierung. max_tokens ist ein striktes Limit.



Thinking mit Tool-Nutzung

Thinking funktioniert zusammen mit Tool-Nutzung und lässt Claude die Tool-Auswahl durchdenken und Tool-Ergebnisse verarbeiten. Zwei Einschränkungen gelten:

1. Tool-Choice-Einschränkung (manueller Modus): Tool-Nutzung mit manuellem erweitertem Denken (thinking: {type: "enabled"}) unterstützt nur tool_choice: {"type": "auto"} (der Standard) oder tool_choice: {"type": "none"}. Die Verwendung von tool_choice: {"type": "any"} oder tool_choice: {"type": "tool", "name": "..."} führt zu einem Fehler, weil diese Optionen Tool-Nutzung erzwingen, was mit manuellem erweitertem Denken inkompatibel ist. Adaptives Thinking, einschließlich bei Modellen, bei denen Thinking standardmäßig aktiviert ist, unterstützt erzwungene Tool-Nutzung.
2. Thinking-Blöcke bewahren: Wenn du Tool-Ergebnisse zurückgibst, musst du die Thinking-Blöcke aus der Assistant-Nachricht vollständig und unverändert an die API zurückgeben. Siehe Thinking-Blöcke bewahren.

Eine Tool-Nutzungs-Schleife ist ein Assistant-Turn. Aus Sicht des Modells ist ein Assistant-Turn erst abgeschlossen, wenn Claude seine vollständige Antwort beendet hat, die mehrere Tool-Aufrufe und -Ergebnisse umfassen kann. Diese gesamte Sequenz ist ein einzelner Assistant-Turn:

User: "What's the weather in Paris?"
Assistant: [thinking] + [tool_use: get_weather]
User: [tool_result: "20°C, sunny"]
Assistant: [text: "The weather in Paris is 20°C and sunny"]

Der gesamte Turn läuft in einem einzigen Thinking-Modus: Du kannst Thinking nicht mitten in einem Turn umschalten, auch nicht während der Tool-Nutzungs-Schleife. Im erweiterten (manuellen) Modus erzwingt die API zusätzlich, dass der letzte Assistant-Turn einer Thinking-aktivierten Anfrage mit einem Thinking-Block beginnt. Der adaptive Modus lockert dies: Kein Assistant-Turn muss mit einem beginnen.

Konflikte mitten im Turn werden graceful abgebaut. Wenn du Thinking mitten im Turn umschaltest (zum Beispiel zwischen dem Senden eines Tool-Aufrufs und dem Zurückgeben seines Ergebnisses), gibt die API keinen Fehler aus. Stattdessen deaktiviert sie Thinking stillschweigend für diese Anfrage. Um die Modellqualität zu erhalten, kann die API Thinking-Blöcke entfernen, die eine ungültige Turn-Struktur erzeugen würden, oder Thinking deaktivieren, wenn der Konversationsverlauf mit aktiviertem Thinking inkompatibel ist. Um zu bestätigen, ob Thinking aktiv war, prüfe auf das Vorhandensein von thinking-Blöcken in der Antwort.

Schalte zwischen Turns um, nicht innerhalb. Plane deine Thinking-Strategie am Anfang jedes Turns. Schließe den Assistant-Turn ab, dann ändere die Thinking-Konfiguration für den nächsten:

User: "What's the weather?"
Assistant: [tool_use] (thinking disabled)
User: [tool_result]
Assistant: [text: "It's sunny"]
User: "What about tomorrow?"
Assistant: [thinking] + [text: "..."] (thinking enabled - new turn)

Das Umschalten von Thinking-Modi invalidiert auch das Prompt-Caching. Siehe Thinking und Prompt-Caching.



Thinking-Blöcke bewahren

Wenn Claude ein Tool aufruft, pausiert es die Konstruktion seiner Antwort, um auf externe Informationen zu warten. Wenn du das Tool-Ergebnis zurückgibst, baut Claude dieselbe Antwort weiter, sodass sein früheres Reasoning noch vorhanden sein muss. Gib jeden thinking-Block vollständig und unverändert an die API zurück, zusammen mit dem tool_use-Block, den er begleitet hat. Das ist aus zwei Gründen wichtig:

1. Reasoning-Kontinuität: Die Thinking-Blöcke erfassen das schrittweise Reasoning, das zu den Tool-Anfragen geführt hat. Wenn du sie einschließt, kann Claude dort weiterdenken, wo es aufgehört hat.
2. Kontexterhaltung: Tool-Ergebnisse erscheinen in der API-Struktur als User-Nachrichten, aber sie sind Teil eines kontinuierlichen Reasoning-Flusses. Das Bewahren von Thinking-Blöcken erhält diesen Fluss über API-Aufrufe hinweg.

Kurz gesagt:

• Erforderlich: Innerhalb eines Tool-Nutzungs-Turns gib Thinking-Blöcke zurück.
• Empfohlen: Über Turns hinweg gib alles zurück.
• Erlaubt: Außerhalb der Tool-Nutzung lasse das Thinking früherer Turns weg.

Du musst altes Thinking nicht selbst bereinigen. Gib alle Thinking-Blöcke in Multi-Turn-Konversationen zurück, und die API filtert sie automatisch, behält die Blöcke, die zum Erhalt des Reasonings des Modells nötig sind, und berechnet Input-Token nur für die Blöcke, die Claude tatsächlich gezeigt werden. Welche Blöcke aus früheren Turns behalten werden, ist modellabhängig. Siehe Thinking-Block-Bewahrung nach Modell. Um den Standard zu überschreiben, verwende die clear_thinking_20251015-Context-Editing-Strategie.

Innerhalb der letzten Assistant-Nachricht muss die Sequenz aufeinanderfolgender thinking-Blöcke dem entsprechen, was das Modell in der ursprünglichen Anfrage generiert hat: Du kannst sie nicht neu anordnen, bearbeiten oder teilweise weglassen. Dies schließt redacted_thinking-Blöcke ein.

Für eine vollständige Zwei-Turn-Anleitung mit Code in jedem SDK siehe Thinking in Tool- und Multi-Turn-Workflows. Sie definiert ein Tool, empfängt eine Thinking-plus-Tool-Use-Antwort und gibt den Assistant-Turn mit dem Tool-Ergebnis zurück.



Interleaved Thinking

„Interleaved thinking" (verschachteltes Denken) lässt Claude zwischen Tool-Aufrufen denken und über jedes Tool-Ergebnis nachdenken, bevor es darauf reagiert. Mit Interleaved Thinking kann Claude:

• Über die Ergebnisse eines Tool-Aufrufs nachdenken, bevor es entscheidet, was als Nächstes zu tun ist
• Mehrere Tool-Aufrufe mit Reasoning-Schritten dazwischen verketten
• Nuanciertere Entscheidungen basierend auf Zwischenergebnissen treffen

Mit adaptivem Thinking ist Interleaved Thinking bei jedem Modell automatisch, das adaptives Thinking unterstützt. Kein Beta-Header ist nötig. Bei Claude Fable 5, Claude Mythos 5, Claude Mythos Preview, Claude Opus 5, Claude Opus 4.8 und Claude Opus 4.7 erscheint Reasoning zwischen Tool-Aufrufen immer in Thinking-Blöcken. Claude Haiku 4.5 unterstützt kein Interleaved Thinking. Bei Modellen, die manuelles erweitertes Denken verwenden, erfordert Interleaving einen Beta-Header und ändert, wie das Thinking-Budget gezählt wird. Interleaved Thinking im manuellen Modus behandelt die modellspezifischen Regeln und das plattformspezifische Header-Verhalten.

Mit Interleaved Thinking kann sich die Thinking-Zuteilung über den gesamten Assistant-Turn erstrecken statt über eine einzelne Antwort. Interleaved Thinking wird nur für Tools unterstützt, die über die Messages-API verwendet werden.

Für einen ausgearbeiteten Vergleich, der zeigt, was Interleaved Thinking in einem Zwei-Tool-Workflow ändert, siehe Wie Interleaved Thinking den Ablauf ändert.



Thinking-Block-Bewahrung nach Modell

Ob Thinking-Blöcke aus früheren Assistant-Turns standardmäßig im Kontext bleiben, hängt vom Modell ab:

• Alle früheren Turns behalten: Claude Opus 4.5 und spätere Opus-Modelle, Claude Sonnet 4.6 und spätere Sonnet-Modelle, Claude Fable 5, Claude Mythos 5 und Claude Mythos Preview.
• Nur den letzten Turn behalten: frühere Opus- und Sonnet-Modelle sowie alle Haiku-Modelle bis einschließlich Claude Haiku 4.5. Wenn du ältere Thinking-Blöcke zurückgibst, entfernt die API sie automatisch. Du musst sie nicht selbst entfernen.

Die Bewahrung bringt zwei Vorteile:

• Cache-Optimierung: Bewahrte Thinking-Blöcke ermöglichen Cache-Treffer während der Tool-Nutzung, da sie mit Tool-Ergebnissen zurückgegeben und inkrementell über den Assistant-Turn hinweg gecacht werden, was zu Token-Einsparungen in mehrstufigen Workflows führt.
• Keine Auswirkung auf die Intelligenz: Das Bewahren von Thinking-Blöcken hat keine negative Auswirkung auf die Modellleistung.

Der Kompromiss ist die Kontextnutzung: Lange Konversationen verbrauchen bei Keep-All-Modellen mehr Kontextplatz, weil behaltene Thinking-Blöcke wie jeder andere Konversationsverlauf als Input zählen (siehe Thinking und das Kontextfenster). Das Verhalten ist in beiden Regimen automatisch. Keine Code-Änderungen oder Beta-Header sind erforderlich, und du solltest weiterhin vollständige, unveränderte Thinking-Blöcke zurückgeben, wie in Thinking-Blöcke bewahren beschrieben. Um den Standard in eine der beiden Richtungen zu überschreiben, verwende Thinking-Block-Clearing.

Modelle mitten in der Konversation wechseln. Wenn du zwischen zwei beliebigen Modellen wechselst, zum Beispiel nach einem Classifier-Refusal-Fallback, entferne thinking- und redacted_thinking-Blöcke aus früheren Assistant-Turns. Thinking-Blöcke sind an das Modell gebunden, das sie erzeugt hat. Andere Modelle ignorieren sie stillschweigend, anstatt die Anfrage abzulehnen, aber ignorierte Blöcke fügen trotzdem Input-Token hinzu.



Thinking und Prompt-Caching

Prompt-Caching interagiert mit Thinking auf einige spezifische Weisen. Die folgenden Regeln gelten in beiden Thinking-Modi.

Konfigurationsänderungen invalidieren das Caching. Die Thinking-Konfiguration und die aufgelöste effort-Stufe werden in den Prompt selbst gerendert, sodass das Ändern einer davon ein neues Cache-Präfix startet. Das Wechseln zwischen adaptive, enabled und disabled, das Ändern von budget_tokens und das Ändern des Effort-Werts invalidieren alle Cache-Breakpoints: Breakpoints auf Nachrichtenebene verfehlen immer, und Tool- und System-Prompt-Breakpoints können ebenfalls verfehlen, je nachdem, wo das Modell die Konfiguration rendert. Behandle jede Thinking- oder Effort-Änderung als Neustart des Caches. Aufeinanderfolgende Anfragen, die dieselbe Konfiguration beibehalten, bewahren den Cache, und das explizite Setzen eines Parameters auf seinen Standardwert ist äquivalent zum Weglassen. Eine ausgearbeitete Demonstration mit Usage-Ausgabe findest du auf der Seite Thinking steuern.

Thinking-Blöcke werden mit Tool-Ergebnissen gecacht. Während einer Tool-Nutzungs-Schleife erfolgt das Caching, wenn du eine Folgeanfrage stellst, die Tool-Ergebnisse enthält. Zu diesem Zeitpunkt kann der vorherige Konversationsverlauf, einschließlich seiner Thinking-Blöcke, gecacht werden, und diese gecachten Thinking-Blöcke zählen als Input-Token in deinen Usage-Metriken, wenn sie aus dem Cache gelesen werden. Dies geschieht automatisch, auch ohne explizite cache_control-Marker, und verhält sich für reguläres und Interleaved Thinking gleich. Der Kompromiss: Thinking-Blöcke, die du nie wieder in Antworten siehst, tragen trotzdem zur Input-Token-Nutzung bei, wenn sie aus dem Cache gelesen werden.

Ob frühere Blöcke überhaupt im Kontext sind, ist modellabhängig. Der Bewahrungsstandard regelt dies. Bei Keep-All-Modellen bleiben Thinking-Blöcke früherer Turns gecacht und im Kontext. Bei Last-Turn-Only-Modellen werden, sobald du eine User-Nachricht sendest, die kein Tool-Ergebnis ist, alle vorherigen Thinking-Blöcke aus dem Kontext entfernt. Bei diesen Modellen wird eine Konversation wie diese:

User: ["What's the weather in Paris?"],
Assistant: [thinking_block_1] + [tool_use block 1],
User: [tool_result_1, cache=True],
Assistant: [thinking_block_2] + [text block 2],
User: [Text response, cache=True]

so verarbeitet, als wären die Thinking-Blöcke nie da gewesen:

User: ["What's the weather in Paris?"],
Assistant: [tool_use block 1],
User: [tool_result_1, cache=True],
Assistant: [text block 2],
User: [Text response, cache=True]

Bei Keep-All-Modellen behält dieselbe Anfrage thinking_block_1 und thinking_block_2 im Kontext und im Cache.

Degradation entfernt Thinking aus dem cachebaren Verlauf. Wenn Thinking mitten im Turn deaktiviert wird und du Thinking-Inhalte im aktuellen Tool-Nutzungs-Turn übergibst, werden die Thinking-Inhalte entfernt und Thinking bleibt für diese Anfrage deaktiviert (siehe Graceful Degradation). Interleaved Thinking verstärkt Cache-Invalidierungseffekte, weil Thinking-Blöcke zwischen mehreren Tool-Aufrufen auftreten können.



Thinking und das Kontextfenster

max_tokens, das alles Thinking einschließt, das Claude im aktuellen Turn generiert, wird als striktes Limit durchgesetzt. Bei Claude-4.5-Modellen und neuer akzeptiert die API die Anfrage, wenn Input-Token plus max_tokens die Kontextfenstergröße überschreitet. Wenn die Generierung dann das Kontextfenster-Limit erreicht, stoppt sie mit stop_reason: "model_context_window_exceeded", anstatt einen Fehler zurückzugeben. Bei früheren Modellen gibt die API stattdessen einen Validierungsfehler zurück. Siehe Umgang mit Stop-Reasons.

Wie Thinking gegen das Fenster zählt, hängt davon ab, wann es generiert wurde:

• Thinking des aktuellen Turns zählt immer zu max_tokens, wird als Output-Token abgerechnet und belegt Kontextfensterplatz für den Turn, der es generiert hat.
• Thinking früherer Turns hängt vom Bewahrungsstandard ab. Bei Modellen, die alle früheren Turns behalten, bleiben vorherige Thinking-Blöcke im Kontext, zählen zum Fenster und werden wie der Rest des Konversationsverlaufs als Input-Token abgerechnet. Bei Modellen, die nur den letzten Turn behalten, entfernt die API ältere Thinking-Blöcke automatisch, wenn du sie zurückgibst, sodass sie keinen Fensterplatz oder Input-Token verbrauchen.

In der Praxis:

• Bei Keep-All-Modellen budgetiere dein Kontextfenster so, als wäre Thinking gewöhnlicher Konversationsverlauf, denn das ist es. Lange agentische Sessions sammeln Thinking im Kontext an. Verwende Thinking-Block-Clearing, wenn du Platz zurückgewinnen musst.
• Bei Last-Turn-Only-Modellen ist Thinking nur ein Pro-Turn-Kostenfaktor: Das Thinking jedes Turns zählt gegen das max_tokens dieses Turns und fällt dann aus dem Fenster.

Die folgenden Diagramme veranschaulichen das Last-Turn-Only-Regime (Stripping). Das erste zeigt eine Multi-Turn-Konversation: Der Thinking-Block jedes Turns wird in der Ausgabe generiert, aber nicht in den Input späterer Turns übernommen.

Das zweite zeigt dasselbe Regime mit Tool-Nutzung: Thinking bleibt für die Dauer des Assistant-Turns zusammen mit seinem Tool-Ergebnis im Kontext und fällt dann beim nächsten User-Turn heraus.

Verwende die Token-Counting-API, um genaue Zählungen für deinen spezifischen Anwendungsfall zu erhalten, besonders für Multi-Turn-Konversationen, die Thinking enthalten.



Thinking-Verschlüsselung

Vollständiger Thinking-Inhalt wird verschlüsselt und im signature-Feld jedes Thinking-Blocks zurückgegeben. Die API verwendet die Signatur, um zu verifizieren, dass Thinking-Blöcke von Claude generiert wurden, wenn du sie zurückgibst.

Beachte Folgendes bei der Arbeit mit Signaturen:

• Es ist nur strikt notwendig, Thinking-Blöcke zurückzusenden, wenn du Tools mit Thinking verwendest. Andernfalls kannst du Thinking-Blöcke aus früheren Turns weglassen. Wenn du sie zurückgibst, hängt es vom Modell ab, ob die API sie behält oder entfernt (siehe Thinking-Block-Bewahrung nach Modell). Verwende Context Editing, um dies zu konfigurieren.
• Wenn du Thinking-Blöcke zurücksendest, gib alles genau so zurück, wie du es erhalten hast, für Konsistenz und um potenzielle Probleme zu vermeiden.
• Beim Streamen von Antworten kommt die Signatur als signature_delta innerhalb eines content_block_delta-Events direkt vor dem content_block_stop-Event an.
• signature-Werte sind in Claude 4 und späteren Modellen deutlich länger als in früheren Modellen.
• Das signature-Feld ist opak: Interpretiere oder parse es nicht.
• signature-Werte sind plattformübergreifend kompatibel (die Claude-API, Amazon Bedrock und Google Cloud). Werte, die auf einer Plattform generiert wurden, funktionieren auf einer anderen.



Redacted-Thinking-Blöcke

Zusätzlich zu regulären thinking-Blöcken kann die API redacted_thinking-Blöcke zurückgeben, wenn Teile von Claudes Reasoning aus Sicherheitsgründen geschwärzt werden. Ein redacted_thinking-Block enthält verschlüsselten Thinking-Inhalt in einem data-Feld, ohne lesbaren Text:

{
  "type": "redacted_thinking",
  "data": "..."
}

Das data-Feld ist opak und verschlüsselt. Wie das signature-Feld bei regulären Thinking-Blöcken gib redacted_thinking-Blöcke unverändert an die API zurück, wenn du eine Multi-Turn-Konversation mit Tools fortsetzt.



Thinking-Ausgabe bei Claude Fable 5 und Claude Mythos 5

Bei Claude Fable 5 und Claude Mythos 5 wird die rohe Gedankenkette nie zurückgegeben. Die Blöcke, die du erhältst, sind reguläre thinking-Blöcke, nicht redacted_thinking, und die display-Einstellung funktioniert genauso wie bei anderen Modellen (zusammengefasster Text oder ein leeres thinking-Feld bei omitted, dem Standard hier). Für die Antwortform von Thinking-Blöcken siehe die Messages-API-Referenz.

Wenn du eine Konversation auf demselben Modell fortsetzt, gib jeden Thinking-Block genau so an die API zurück, wie du ihn erhalten hast, einschließlich Blöcken, deren thinking-Feld leer ist. Bearbeite oder rekonstruiere sie nicht. Das Lesen des Zusammenfassungstexts zur Anzeige ist in Ordnung: Die API lehnt Blöcke ab, deren zurückgegebener Inhalt modifiziert wurde, nicht Blöcke, die du gelesen hast. Text, der in ein leeres ausgelassenes thinking-Feld eingefügt wird, wird ignoriert statt abgelehnt.

Wie Thinking-Blöcke behandelt werden, wenn du mitten in der Konversation Modelle wechselst, siehe Thinking-Block-Bewahrung nach Modell.

Zwei Ausnahmen, behandelt in Fallback-Credit:

• Fallback-Credit-Retries müssen den abgelehnten Request-Body unverändert zurückgeben.
• fallback-Blöcke aus einem Mid-Output-Fallback bleiben dort, wo sie erschienen sind.

Um Einblick in das Reasoning des Modells zu erhalten, lies die auf dieser Seite beschriebenen thinking-Blöcke, anstatt im Antworttext nach Reasoning zu prompten. Bei Claude Fable 5 kann eine Anfrage, die versucht, das interne Reasoning des Modells als Teil des Antworttexts hervorzulocken, mit stop_details.category: "reasoning_extraction" abgelehnt werden. Siehe Refusal-Kategorien für die Feldreferenz und Handhabungshinweise.



Limits und Feature-Kompatibilität

Sampling-Parameter. Bei Claude Fable 5, Claude Mythos 5, Claude Mythos Preview, Claude Opus 5, Claude Opus 4.8, Claude Opus 4.7 und Claude Sonnet 5 geben nicht-standardmäßige Werte für temperature, top_p oder top_k bei jeder Anfrage einen 400-Fehler zurück, unabhängig davon, ob Denken verwendet wird. Bei älteren Modellen gilt die Einschränkung nur, während das Denken aktiviert ist: temperature und top_k sind mit Denken inkompatibel, und top_p ist bei Werten zwischen 0,95 und 1 erlaubt.

Response-Prefill und erzwungene Tool-Nutzung. Du kannst die Assistenten-Antwort nicht vorausfüllen, während das Denken aktiviert ist. Erzwungene Tool-Nutzung (tool_choice: {"type": "any"} oder {"type": "tool", ...}) ist mit manuellem erweitertem Denken inkompatibel, funktioniert aber mit adaptivem Denken. Siehe Denken mit Tool-Nutzung.

Output-Limits. Claude Fable 5, Claude Mythos 5, Claude Mythos Preview, Claude Opus 5, Claude Opus 4.8, Claude Opus 4.7, Claude Sonnet 5, Claude Opus 4.6 und Claude Sonnet 4.6 unterstützen bis zu 128k Output-Token pro Anfrage. Claude Haiku 4.5, Claude Sonnet 4.5 und Claude Opus 4.5 unterstützen bis zu 64k. In der Message Batches API erhöht der output-300k-2026-03-24 Beta-Header das Limit auf 300k für Claude Opus 5, Claude Opus 4.8, Claude Opus 4.7, Claude Sonnet 5, Claude Opus 4.6 und Claude Sonnet 4.6. Siehe die Modellübersicht für Limits bei Legacy-Modellen.

Lange Anfragen. Die SDKs erfordern Streaming, wenn max_tokens größer als 21.333 ist, um HTTP-Timeouts bei lang laufenden Anfragen zu vermeiden. Dies ist eine clientseitige Validierung, keine API-Einschränkung. Wenn du Events nicht inkrementell verarbeiten musst, verwende .stream() mit .get_final_message() (Python) oder .finalMessage() (TypeScript), um das vollständige Message-Objekt zu erhalten, ohne einzelne Events zu verarbeiten. Siehe Streaming Messages. Rechne mit längeren Antwortzeiten, wenn das Denken aktiv ist, da das Generieren von Thinking-Blöcken zusätzliche Verarbeitungszeit erfordert. Für Workloads, bei denen das Denken etwa 32k Token pro Anfrage überschreitet, verwende Batch-Verarbeitung, um Netzwerkprobleme zu vermeiden: Solche Anfragen können lange genug laufen, um System-Timeouts und Limits für offene Verbindungen zu erreichen.



Nächste Schritte